Observer Pattern (观察者模式)

介绍

观察者模式是一个使用频率很高的模式。常用在 GUI系统，发布-订阅系统。 这个模式的一个重要作用就是 解耦，将观察者 和 被观察者 解耦，使得它们之间的依赖性更小，甚至做到毫无依赖。

定义

定义对象之间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。

使用场景

• 关联行为场景，注意“关联”关系可拆分，不是“组合”关系。
• 跨系统的信息交互场景，如消息队列、事件总线的处理机制。

类图

Observer Pattern UML

Observable：被观察的角色，被观察者把所有观察者对象的引用保存在一个集合里，每个 Observable 都可以有任意数量的观察者，Observable 提供一个接口，可以增加和删除观察者对象。

Observer：抽象观察者，该角色是观察者的抽象类，它定义了一个更新接口，使得在得到 被观察者 更新通知时更新自己。

ConcreteSubject：具体被观察者，该角色将有关状态存入具体观察者对象，在 ConcreteSubject 内部状态发生变化时，给所有注册过的观察者发出通知。

ConcreteObserver：具体的观察者，该角色实现抽象观察者角色所定义的更新接口，以便在 被观察者 的状态发生变化时更新自身的状态。

UML中 具体的观察者 和 具体的被观察者 是解耦的，双方都不需要知道对方是谁，甚至可以不知道对方的存在，这是通过更高层次的接口抽象达到的。

应用

自1.0版本开始，JDK 中已经内置了通用版本的 Observable： java.util.Observable 和 Observer：java.util.Observer 的抽象。 我们来看一下它们怎么实现的。

java.util.Observer ：

public interface Observer {
    void update(Observable o, Object arg);
}

java.util.Observable ：

public class Observable {
    private boolean changed = false;    //表示被观察者状态的标识
    private Vector<Observer> obs;       //观察者集合
    //构造函数
    public Observable() {
        obs = new Vector<>();
    }
   
    //添加观察者
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    //删除观察者
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    //通知所有观察者更新
    public void notifyObservers() {
        notifyObservers(null);
    }

    //通知所有观察者更新
    public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    //清空观察者集合
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    //设置状态标识改变  true
    protected synchronized void setChanged() {
        changed = true;
    }

    //清除change标识  false
    protected synchronized void clearChanged() {
        changed = false;
    }

   // 返回标识的值
    public synchronized boolean hasChanged() {
        return changed;
    }

   //返回观察者的个数
    public synchronized int countObservers() {
        return obs.size();
    }
}

实践

使用 jdk 中的抽象进行实践。

// 被观察者 
public class Teacher extends Observable {
    public void updateObserver(){
        setChanged();
        notifyObservers("下周一放学之前必须交作业");
    }
}

// 观察者
public class Student implements Observer {
    private String name;

    public Student(String name){
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(this.name + " " + arg);
    }
}

Teacher teacher = new Teacher();
Student s1 = new Student("Jack");
Student s2 = new Student("Tim");
Student s3 = new Student("LiLi");
teacher.addObserver(s1);
teacher.addObserver(s2);
teacher.addObserver(s3);

teacher.updateObserver();

运行结果：

LiLi 下周一放学之前必须交作业
Tim 下周一放学之前必须交作业
Jack 下周一放学之前必须交作业