监听器模式观察者模式

Posted 2021-01-17 lebo0425

最近在学习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点：

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

这里为了方便，直接用了 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事件源便可回调具体监听器动作。

观察者模式

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

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

为了方便，同样直接使用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");
    }
}

• 控制台输出

打开窗口
关闭窗口

总结

从实现和调用过程来看，观察者和监听器模式基本一样。基本上都是这个逻辑当事件源对象上发生操作时，它将调用事件监听器的一个方法，并将事件对象传递过去，套用到观察者模式上面就是，当被观察者发生操作时，观察者将根据被观察者所做出的操作 进行对应的操作。

应用

1. netty中监听连接
2. guava 中的 ListenableFuture，采用监听器模型解决了原生JDK中 future.get() 一直阻塞结果的问题。

参考文章：https://my.oschina.net/u/923324/blog/792857