观察者模式

观察者模式

观察者模式，定义了对象之间一对多的依赖，当一个对象的状态改变的时候，它的所有依赖者都会收到通知，并自动更新。
观察者模式也叫做 发布-订阅模式。这个被依赖的对象也叫做主题（Subject），而这些依赖着主题的对象叫做观察者（Observer）。

UML

根据定义画出以下类图

Subject：主题，需要维护一个观察者的列表，以及数据改变的时候通知的方法。
Observer：观察者接口，规范观察者
ConcreteObserver：具体的观察者

代码实现

主题

public class Subject {
  private List<Observer> observerList = new ArrayList<>();
    private String name;
    private Integer weight;

    public Subject(String name, Integer weight) {
        this.name = name;
        this.weight = weight;
    }
// 改变的时候，里面就会调用一次notifyObservers的方法通知所有观察者
    public void change(){
        System.out.println(name+"当前体重:"+weight);
        weight--;
        System.out.println("少吃了一顿夜宵，"+name+"现在的体重是："+weight);
        notifyObservers();
    }
    // 观察者注册
    public void addObserver(Observer observer){
        observerList.add(observer);
    }
    // 通知所有观察者
    private void notifyObservers(){
        observerList.forEach((observer)->{observer.update(this);});
    }

    public String getName() {
        return name;
    }

    public Integer getWeight() {
        return weight;
    }
}

观察者接口

public interface Observer {
    void update(Subject subject);
}

具体观察者1

public class Observer1 implements Observer {
   @Override
    public void update(Subject subject) {
        System.out.println("=================================================");
        System.out.println("小B发现"+subject.getName()+"的体重是："+subject.getWeight());
        System.out.println("但是不为所动");
        System.out.println("=================================================");
    }
}

具体观察者2

public class Observer2 implements Observer {
 @Override
    public void update(Subject subject) {
        System.out.println("=================================================");
        System.out.println("小C发现"+subject.getName()+"的体重是："+subject.getWeight());
        System.out.println("开始减肥");
        System.out.println("=================================================");
    }
}

  public static void main(String[] args) {
        Subject subject = new Subject("小红",100);
        subject.addObserver(new Observer1());
        subject.addObserver(new Observer2());
        subject.change();
    }

运行结果：

JDK提供的观察者接口

JDK中为了方便开发者也提供了现成的观察者接口和主题，以下直接给出我添加了注释的源码。

Observer

public interface Observer {
	// 接口的update方法
    void update(Observable o, Object arg);
}

Observable

package java.util;

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) {
        Object[] arrLocal;
        synchronized (this) {
        // 如果没有没改变就直接返回
            if (!changed)
                return;
            arrLocal = obs.toArray();
            // 观察者即将对这次的改动做出反应，所以这里就再将这个状态置为false
            clearChanged();
        }
		// 调用观察者的update方法
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

 // 移除所有观察者
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
// 主题被改变，改变这个标记
    protected synchronized void setChanged() {
        changed = true;
    }
// 已通知完，标记改回去
    protected synchronized void clearChanged() {
        changed = false;
    }

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

改造上面的例子,被观察者继承Observable接口，然后在自己的状态改变的时候，这里的weight–，调用一下setChange 和 notifyObservers方法。

public class Subject2 extends Observable {
    private String name;
    private Integer weight;

    public Subject2(String name, Integer weight) {
        this.name = name;
        this.weight = weight;
    }

    public void change(){
        System.out.println(name+"当前体重:"+weight);
        weight--;
        System.out.println("少吃了一顿夜宵，"+name+"现在的体重是："+weight);
        setChanged();
        notifyObservers();
    }

    public String getName() {
        return name;
    }

    public Integer getWeight() {
        return weight;
    }
}

public class Observer1 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("=================================================");
        System.out.println("小B发现"+((Subject2)o).getName()+"的体重是："+((Subject2)o).getWeight());
        System.out.println("但是不为所动");
        System.out.println("=================================================");
    }
}

public class Observer1 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("=================================================");
        System.out.println("小B发现"+((Subject2)o).getName()+"的体重是："+((Subject2)o).getWeight());
        System.out.println("但是不为所动");
        System.out.println("=================================================");
    }
}

总结

因为是面对接口编程，所以观察者分离了 主题 和 观察者 之间的责任，他们各自维护自己的功能。