观察者模式（监听器模式）

观察者模式的实现

 

       观察者模式有很多实现方式，从根本上说，该模式必须包含两个角色：观察者和被观察对象。观察者和被观察者之间存在“观察”的逻辑关联，当被观察者发生改变的时候，观察者就会观察到这样的变化，并且做出相应的响应。

       实现观察者模式的时候要注意，观察者和被观察对象之间的互动关系不能体现成类之间的直接调用，否则就将使观察者和被观察对象之间紧密的耦合起来，从根本上违反面向对象的设计的原则。无论是观察者“观察”观察对象，还是被观察者将自己的改变“通知”观察者，都不应该直接调用。

       实现观察者模式有很多形式，比较直观的一种是使用一种“注册——通知——撤销注册”的形式。下面详细的描述了这样一种过程：

 

     1、观察者

 

　　（Observer）将自己注册到被观察对象（Subject）中，被观察对象将观察者存放在一个容器（Container）里。

 

     2、被观察对象

 

　　被观察对象发生了某种变化（如图中的SomeChange），从容器中得到所有注册过的观察者，将变化通知观察者。

 

      3、撤销观察

 

　　观察者告诉被观察者要撤销观察，被观察者从容器中将观察者去除。

 

       观察者将自己注册到被观察者的容器中时，被观察者不应该过问观察者的具体类型，而是应该使用观察者的接口。这样的优点是：假定程序中还有别的观察者，那么只要这个观察者也是相同的接口实现即可。

 

 

监听器和监听器模式

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

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

包含的元素：

                          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!

 

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

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