ObserverPattern观察者模式

观察者模式

1.定义

在对象之间定义一种一对多的依赖关系，使得当一个对象的状态的发生改变时，依赖它的所有对象都会得到通知并被自动更新。观察者模式也叫做发布订阅模式。

观察者模式通常有四个角色

AbstractSubject：抽象被观察者。定义被观察者必须实现的全部职责，且能够动态的增加或取消观察者。通常是一个抽象类。

public abstract class AbstractSubject {

    /** 定义一个观察者集合 **/
    private Vector<AbstractObserver> observers = new Vector<>();

    /**
     * 添加一个观察者
     * @param observer
     */
    public void addObserver(AbstractObserver observer) {
        this.observers.add(observer);
    }

    /**
     * 移除一个观察者
     * @param observer
     */
    public void removeObserver(AbstractObserver observer) {
        this.observers.remove(observer);
    }

    public void notifyAllObservers() {
        for (AbstractObserver observer : observers) {
            observer.run();
        }
    }
}

AbstractObserver：抽象观察者。定义接收到通知时的动作。

public interface AbstractObserver {

    /** 定义接收到通知时的动作 **/
    void run();
}

Subject：被观察者。实现自己的业务逻辑，定义对哪些事件进行通知。

public class Subject extends AbstractSubject {

    public void doSomething() {
        System.out.println("被观察者具体业务逻辑");

        super.notifyAllObservers();
    }

}

Observer：观察者。实现自己对通知的处理逻辑。

public class ObserverOne implements AbstractObserver {

    @Override
    public void run() {
        System.out.println("观察者ObserverOne接收到通知并处理！");
    }
}

public class ObserverTwo implements AbstractObserver {

    @Override
    public void run() {
        System.out.println("观察者ObserverTwo接收到通知并处理！");
    }
}

场景类

public class Client {

    public static void main(String[] args) {
        // 定义被观察者
        Subject subject = new Subject();

        // 定义观察者
        AbstractObserver observerOne = new ObserverOne();
        AbstractObserver observerTwo = new ObserverTwo();

        // 观察者监视被观察者
        subject.addObserver(observerTwo);
        subject.addObserver(observerOne);

        subject.doSomething();
    }
}

2.应用

2.1 优点

观察者与被观察者之间是抽象耦合。两者都容易扩展。
建立了一套触发机制。

2.2 缺点

消息通知是顺序执行，当有多个观察者时，开发和运行效率低，且一旦有一个观察者卡壳会影响整个触发链的执行效率。该情况下考虑使用异步方式。
当多级触发时，效率非常低。

2.3 使用场景

事件的多级触发
跨系统消息交换，如消息队列的处理机制。

2.4 注意事项

多级触发链逻辑复杂，可维护性差。建议避免一个对象既是观察者也是被观察者。
观察者异步触发需要考虑线程安全及队列问题。

3.扩展

JDK中提供了java.util.Observable实现类和java.util.Observer接口，可以用来很方便的实现观察者模式。

优化后的被观察者

public class Subject extends Observable,AbstractSubject {

    public void doSomething() {
        System.out.println("被观察者具体业务逻辑");

        super.notifyAllObservers();
    }

}

优化后的观察者

public class ObserverOne implements Observer {

    public void update(Observable observable, Object object) {
        System.out.println("观察者ObserverOne接收到通知并处理！");
    }
}

java.util.Observer要求update传递两个参数，被观察者及数据传输对象（由被观察者生成，由观察者消费）。

观察者实现快速响应的两种方式。一是多线程技术，二是缓存技术。