Head First Design Patterns学习笔记-观察者模式

认识观察者模式

首先来看看报纸订阅的过程

• 1.报社的业务就是出版报纸
• 2.向某家报社订阅报纸，只要他们有新报纸出版，就会送过来，只要你是他们的订户
• 3.当你不想再看报纸的时候，取消订阅，他们就不会再送新报纸
• 4.只要报社还在运营，就会一直有人来订阅或取消订阅报纸

观察者模式和报纸订阅流程是一样的，只是名字不同。出版社改名为主题（Subject），而订阅者改名为观察者（Observer）

观察者模式的定义

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。

观察者模式代码

//主题接口
interface Subject {
    void registerObserver(Observer o);//增加观察者
    void removeObserver(Observer o);//删除观察者
    void notifyObservers();//当主题状态改变时，调用此方法通知所有观察者
}
//观察者接口
interface Observer {
    void update(float temp); //用来接收主题发送的通知，这里假设主题是温度计，通过接口给观察者发送当前温度
}
//主题实现
class Thermometer implements Subject {
    private List<Observer> observers = new ArrayList<>();//观察者集合
    private float temp = 0.0f;//温度
    public void setTemp(float temp) {//温度更新
        this.temp = temp;
        notifyObservers();
    }
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    @Override
    public void removeObserver(Observer o) {
        if (observers.indexOf(o) >= 0)
            observers.remove(o);
    }
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temp);
        }
    }
}
//观察者实现
class ObserverA implements Observer {
    @Override
    public void update(float temp) {
        System.out.println("观察者A：当前的温度是" + temp);
    }
}
class ObserverB implements Observer {
    @Override
    public void update(float temp) {
        System.out.println("观察者B：当前的温度是" + temp);
    }
}
public class JavaApplication {
    public static void main(String[] args) throws Exception{
       //具体使用
       Thermometer t = new Thermometer();
       Observer a = new ObserverA();
       Observer b = new ObserverB();
       //为a,b注册成为ts的观察者
       t.registerObserver(a);
       t.registerObserver(b);
       //更新温度
       t.setTemp(23.00f);
       //a不再当观察者
       t.removeObserver(a);
       //更新温度
       t.setTemp(24.00f);
    }
}

另外，Java中已经内置了观察者模式，在java.util包下有Observer接口和Observable类

和这里的Subject接口和Observer接口很相似，修改后的代码如下

//主题实现
class Thermometer extends Observable{
    private float temp = 0.0f;//温度
    public void setTemp(float temp) {//温度更新
        this.temp = temp;
        setChanged();//说明状态已改变
        notifyObservers(temp);
    }
}
//观察者实现
class ObserverA implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("观察者A：当前的温度是" + arg);
    }
}
class ObserverB implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("观察者B：当前的温度是" + arg);
    }
}
public class JavaApplication {
    public static void main(String[] args) throws Exception{
       //具体使用
       Thermometer t = new Thermometer();
       Observer a = new ObserverA();
       Observer b = new ObserverB();
       //为a,b注册成为ts的观察者
       t.addObserver(a);
       t.addObserver(b);
       //更新温度
       t.setTemp(23.00f);
       //a不再当观察者
       t.deleteObserver(a);
       //更新温度
       t.setTemp(24.00f);
    }
}

另外，既然JDK是开源的，那么就顺便去看看JDK的源码中的具体实现

(这里使用的源码版本为jdk1.8.0_74)

Observable对象：(大部分没什么区别的代码就不放出来了)

public Class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    ...
}

私有成员变量，一个是标志，用于后续判断是否通知观察者，一个观察者集合obs，使用的是Vector容器

标志的用途是用于增加自由度，比如说一秒钟更新10次数据，对于前台显示而言可能不需要这么频繁，那么我们可以自己计数，如果达到10次才设置标志

可以在通知观察者方法源码里看到changed的作用

public void notifyObservers(Object arg) {
    Object[] arrLocal;
    synchronized (this) {
        if (!changed)
            return;
        arrLocal = obs.toArray();
        clearChanged();//clearChanged方法里的具体代码就一句：changed = false;
    }
    for (int i = arrLocal.length-1; i>=0; i--)
        ((Observer)arrLocal[i]).update(this, arg);
}

而Observer接口更是没什么好说的

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

相对于我们自己实现的观察者模式，主要区别在于将ArrayList换成了Vector，方法都加上了synchronized关键字来保证线程安全，并没有什么特别的← ←