监听器模式、观察者模式

来源：cnblogs　　作者：土豆蛋炒饭　　时间：2018/11/6 10:22:06　　对本文有异议

最近在学习netty的时候，发现里面用到了监听器模式，感觉非常实用，以前看设计模式的时候只是看，并没有用上。其实这是一个非常重要并实用的设计模式，在很多框架里面都用到了。

netty里面的应用：

    serverBootstrap.bind(8000).addListener(new GenericFutureListener<Future<? super Void>>() {
        public void operationComplete(Future<? super Void> future) {
            if (future.isSuccess()) {
                System.out.println("端口绑定成功!");
            } else {
                System.err.println("端口绑定失败!");
            }
        }
    });

回调函数

为什么先提到回调函数呢？因为回调函数是理解监听器、观察者模式的关键。刚毕业的时候老大也经常和我说Java中的回调。

wiki中的定义：

回调函数，或简称回调（Callback 即call then back 被主函数调用运算后会返回主函数），是指通过函数参数传递到其它代码的，某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序。

通俗的定义：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法。

demo：这里有两个实体，回调抽象者接口、回调者（程序a）

回调接口（ICallBack）

public interface ICallBack {
    public void callBack();
}

回调者（用于调用回调函数的类）

public class Caller {
    
    public void call(ICallBack callBack) {
        System.out.println("start...");
        callBack.callBack();
        System.out.println("end...");
    }
    
}

回调测试

public class CallDemo {
    public static void main(String[] args) {
        Caller caller = new Caller();
        caller.call(() -> System.out.println("回调成功"));
    }
}

控制台输出

start...
回调成功
end...

这个模型和执行一个线程Thread很像。没错，Thread就是回调者，Runnable就是一个回调接口。

事件监听器

事件监听器就是自己监听的事件一旦被触发或改变，立即得到通知，做出响应。

Java的事件监听机制可概括为3点：

Java的事件监听机制涉及到事件源，事件监听器，事件对象三个组件,监听器一般是接口，用来约定调用方式
当事件源对象上发生操作时，它将调用事件监听器的一个方法，并将事件对象传递过去
事件监听器实现类，通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理

这里为了方便，直接用了 jdk，EventListener 监听器

监听器接口

public interface EventListener extends java.util.EventListener {
    /**
     * 事件处理
     */
    void handleEvent(EventObject eventObject);
}

事件对象

public class EventObject extends java.util.EventObject {
    public EventObject(Object source) {
        super(source);
    }
    public void doEvent() {
        System.out.println("通知一个事件源 source:" + this.getSource());
    }
}

事件源

public class EventSource {
    // 监听器列表，监听器的注册 加入此列表
    private List<EventListener> listeners = new ArrayList<>();
    public void addListener(EventListener eventListener) {
        listeners.add(eventListener);
    }
    public void removeListener(EventListener eventListener) {
        listeners.remove(eventListener);
    }
    public void notifyListenerEvent(EventObject eventObject) {
        for (EventListener eventListener : listeners) {
            eventListener.handleEvent(eventObject);
        }
    }
}

测试执行

public class EventDemo {
    public static void main(String[] args) {
        EventSource eventSource = new EventSource(); // 事件源
        eventSource.addListener(new EventListener() { // 事件源 调用监听器的一个方法，并传递事件对象
            @Override
            public void handleEvent(EventObject eventObject) {
                eventObject.doEvent();
                if (eventObject.getSource().equals("closeWindow")) {
                    System.out.println("doClose"); // 回调
                }
            }
        });
        EventObject eventObject = new EventObject("closeWindow"); // 事件对象
        eventSource.notifyListenerEvent(eventObject); // 触发事件
    }
}

控制台输出

通知一个事件源 source:closeWindow
doClose

到这里我们了解了什么是监听器模式了。EventListener是一个回调接口类，handleEvent是一个回调函数接口，通过回调模型，EventSource事件源便可回调具体监听器动作。

观察者模式

观察者模式的原理其实和监听器一样，使用的关键在于搞清楚什么是观察者、什么是被观察者

观察者相当于事件监听
被观察者相当于事件源和事件

为了方便，同样直接使用jdk自带的Observer

观察者

public class Watcher implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if (arg.toString().equals("openWindow")) {
            System.out.println("打开窗口");
        }
    }
}

被观察者

public class Watched extends Observable {
    public void notifyObservers(Object arg) {
        /**
         * 为了避免并发冲突，设置了 changed 标志位 changed=true，则当前线程可以通知所有观察者，内部同步块会设置为false；
         * 通知过程中，正在新注册的和撤销的无法通知到
         */
        super.setChanged();
        /**
         * 事件触发，通知所有感兴趣的观察者
         */
        super.notifyObservers(arg);
    }
}

测试执行

public class WatcherDemo {
    public static void main(String[] args) {
        Watched watched = new Watched();
        Watcher watcher = new Watcher();
        watched.addObserver(watcher);
        watched.addObserver(new Observer() {
            @Override
            public void update(Observable o, Object arg) {
                if (arg.toString().equals("closeWindow")) {
                    System.out.println("关闭窗口");
                }
            }
        });
        watched.notifyObservers("openWindow");
        watched.notifyObservers("closeWindow");
    }
}