java 监听器和监听器模式

监听器是观察者模式的一种实现，监听器模式也就是观察者模式的一种。

       监听器模式是对某种共有操作的监控。当此操作执行时对此操作作相应处理。

包含的元素：

                          1. 要监控的事件定义Event

                          2. 监控该事件的监听器Listener

                          3. 要监控的事件操作Action

                          4. 监控者

       元素的职责：

                          1.定义了要监控事件的事件类型定义，和其它和该事件相关的特殊定义

                          2.监听器，用于对事件发生后要执行操作的接口定义

                          3.要监控的事件、操作，对于要监控的事件，他必须要包含被监控事件的注册功能

                          4.监控者要实现要监控的事件接口，完成时间发生后的操作内容

       这里举一个例子，说明监听模式的一般实现：

 

       1、首先要定义事件，监听器处理哪些类型的事件，也就是用什么样的事件来触发监听器，事件的类型很多，这里可以定义一个事件接口来抽象所有事件类型。

/**
 * 事件接口，其中事件的类型定义了三种，创建、删除、更新
 */
public interface MyEvent {
    
    public static final String createEvent = "CREATE_EVENT";
    public static final String deleteEvent = "DELETE_EVENT";
    public static final String updateEvent = "UPDATE_EVENT";


    public String getEvent();
    
}

2、给出一个监听器的接口

/**
 * 定义监听器，该监听器只监听MyEvent类型的事件
 */
public interface MyListener {
    public void handle(MyEvent myEvent);
}

3、监听器的实现，该实现根据事件类型的不同做不同的处理

public class MyListenerImpl implements MyListener {
    public void handle(MyEvent myEvent) {
        if(myEvent.getEvent().equals("CREATE_EVENT")){
            System.out.println("myListener get a create event!");
        }
        else if(myEvent.getEvent().equals("DELETE_EVENT")){
             ... 
        }
         ... 
    }
}

4、有了监听器的实现，肯定需要一个事件的实现，不过事件的实现类可以是专指某个类型的pojo，也可以是一个事件类型在使用时被设置的类，下面的实现是第一种，直接定义了一个create事件的实现类。

public class MyCreateEventImpl implements MyEvent {
    private String type="";
    public MyCreateEventImpl(){
        this.type = MyEvent.createEvent;
    }
    public String getEvent() {
        return this.type;
    }
}

5、基础工作都做好后，就可以在想添加监听的类中实施监听功能了。

public class MyCreateAction {
    //引入监听器
    private MyListener myListener;
    //引入事件，用来传给Listener进行处理
    private static MyEvent myEvent;
    public void setListener(MyListener myListener){
        this.myListener = myListener;
    }
    private void handleListener(MyEvent myEvent){
        //触发监听
        this.myListener.handle(myEvent);
    }
    public void execute(){
        //设置事件的类型为create
        myEvent = new MyCreateEventImpl();
        System.out.println("create start!");
        this.handleListener(myEvent);
        System.out.println("create end!");
    }


    //调用被监听的类，测试监听效果
    public static void main(String[] args) {
        MyCreateAction action = new MyCreateAction();
        MyListenerImpl myListener = new MyListenerImpl();
        //设置监听器的实现
        action.setListener(myListener);
        action.execute();
    }
}

输出的结果为：

 

create start!

myListener get a create event!

create end!

 

至此，监听器模式的基本工作原理就已经十分清楚了。

它实际上就是把一个函数方法注册到一个类中，然后这个类在执行的过程中只要一产生相应的事件，就去调用这个注册进来的函数方法。

有些东西听起来很深奥，只要花时间看一下，再动手实验一把，马上就豁然开朗了~