最近在学习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中的回调。
回调函数，或简称回调（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");
}
}
- 控制台输出
打开窗口
关闭窗口
总结
从实现和调用过程来看，观察者和监听器模式基本一样。基本上都是这个逻辑当事件源对象上发生操作时，它将调用事件监听器的一个方法，并将事件对象传递过去，套用到观察者模式上面就是，当被观察者发生操作时，观察者将根据被观察者所做出的操作 进行对应的操作。
应用
- netty中监听连接
- guava 中的 ListenableFuture，采用监听器模型解决了原生JDK中 future.get() 一直阻塞结果的问题。