观察者模式

概述

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

示例代码

//抽象通知者
abstract class Subject{
    private List<Observer> observers = new ArrayList<>();
    public void attach(Observer observer){
        observers.add(observer);
    }
    public void detach(Observer observer){
        observers.remove(observer);
    }
    abstract void notifyX();
}
//具体通知者
class ConcretSubject extends Subject{
    boolean addition = true;
    public void notifyX(){
        if(addition){
            for (Observer observer : observers) {
                observer.update();
            }
        }
    }
}
//抽象观察者
interface Observer{
    void update();
}
//具体观察者
class AObserver implements Observer{
    @Override
    public void update() {
        System.out.println("stop doing A thing");
    }
}
class BObserver implements Observer{
    @Override
    public void update() {
        System.out.println("stop doing B thing");
    }
}
//客户端
Subject subject = new ConcretSubject();
Observer observerA = new AObserver();
Observer observerB = new BObserver();
subject.attach(observerA);
subject.attach(observerB);
subject.notifyX();

分析

观察者模式的不足：

可以看到，通知者仍然耦合了抽象观察者，但如果是我们拿来别人已经封装好的一组类，需要对其通知，显然，这样一组类没有继承一个抽象观察者或实现一个观察者接口，那么通知者就没有办法通知了；

另外，每一个观察者被通知后，所执行的操作也不一定都是一样的比如都是update方法，不同的观察者会执行各自不同的方法。

我们可以通过事件委托的方式来解决上述不足。C#语法中本身有委托的概念，实现起来很方便，而Java中没有，需要我们自己来实现，通过反射的方式。

事件委托的Java实现

首先定义一个事件类，即通过反射实现方法的调用。

class Event{
    private Object object;
    private String method;
    private Object[] params;
    private Class[] paramTypes;

    public Event(Object object, String method, Object... params) {
        this.object = object;
        this.method = method;
        this.params = params;
        analyseParamTypes(this.params);
    }

    private void analyseParamTypes(Object[] params) {
        this.paramTypes = new Class[params.length];
        for (int i = 0; i < params.length; i++) {
            this.paramTypes[i] = params[i].getClass();
        }
    }
    public void invoke(){
        try {
            Method method = object.getClass().getMethod(this.method, this.paramTypes);
            method.invoke(object, this.params);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

然后定义一个事件管理器，用一个列表存储委托的事件，并实现通知。

class EventHandler{
    private List<Event> events = new ArrayList<>();
    public void addEvents(Object object, String method, Object... params){
        events.add(new Event(object, method, params));
    }
    public void notifyX(){
        for (Event event : events) {
            event.invoke();
        }
    }
}

通知者，通过事件管理器实现事件委托与通知。

class Notifier{
    private EventHandler eventHandler = new EventHandler();
    public void addListener(Object object, String method, Object... params){
        eventHandler.addEvents(object, method, params);
    }
    public void notifyX(){
        eventHandler.notifyX();
    }
}

客户端，通知者与观察者彻底解耦，由客户端决定通知者通知哪一个观察者及其要执行的方法。

Notifier notifier = new Notifier();
AObserver observerA = new AObserver();
notifier.addListener(observerA, "update");
notifier.notifyX();

参考文章：

java实现事件委托——shuciqi