java自定义事件机制分析

 import java.util.ArrayList;
 import java.util.EventListener;
 import java.util.EventObject;
 import java.util.List;

 /**
 * 测试自定义事件
 * @author Administrator
 *
 */
 public class EventTest {

 /**
 * 自定义的一个事件对象
 * @author Administrator
 *
 */
 static class MyEvent extends EventObject {

 private String eventName;

 public MyEvent(String eventName) {
 super(eventName);
 this.eventName = eventName;
 }
 }

 /**
 * 自定义的事件的监听器
 * @author Administrator
 *
 */
 static class MyEventListenor implements EventListener {

 public String fireEvent(EventObject event ) {

 String result = "";

 doHanndler(event);

 return result;
 }

 private void doHanndler(EventObject event) {
 System.out.println(event.toString());
 }
 }

 /**
 * 自定义的事件源
 * @author Administrator
 *
 */
 static class MySysUI {

 private String name;

 /*事件监听器**/
 private List<EventListener> listerors = new ArrayList<EventListener>();

 public MySysUI(String name ) {
 this.name = name;
 }

 /**
 * 添加事件监听器
 * @param listener
 */
 public void addEventListeror(EventListener listener) {
 listerors.add(listener);
 }

 /**
 * 触发业务事件
 * @param params
 */
 private void fireEvent(String params) {
 System.out.println("fireEvent");
 eventNotify(params);
 }

 private void eventNotify(String params) {
 for (EventListener eventListener : listerors) {
 MyEventListenor eventListenerOther = (MyEventListenor)eventListener;

 EventObject event = new EventObject(params);

 eventListenerOther.fireEvent(event );
 }
 }

 /**
 * 业务处理，事件触发对用户来说，无所谓触发什么事件，他们只需完成业务自己的业务即可，里面触发时间业务事件
 * @param prams
 */
 public void doService(String... prams) {

 //用户处理自己该做的业务 doDealService();

 fireEvent("触发doService业务事件");

 }

 }

 /**
 * 入口程序
 * @param args
 */
 public static void main(String[] args) {

 MySysUI mySysUI = new MySysUI("EventSource UI");

 EventListener listeror = new MyEventListenor();

 mySysUI.addEventListeror(listeror );

 mySysUI.doService("执行业务");
 }

 }

一点感悟:
1.本质就是一种观察者模式的实现，是我们自定义业务组件的一直开发思想，结合事件机制进行通信
2.匿名内部类就是一种挂接的扩展接口，有业务使用直接扩展即可，就是接口回调机制  HOOK机制，编程方式比较好，自己去写实现，不破坏整个业务处理的流程机制