设计模式（二）：观察者模式

一、『观察者模式』定义

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

可以用【出版者+订阅者=观察者模式】的方式来类比。

如果你了解报纸的订阅是怎么回事，其实就知道观察者模式是怎么回事，只是名称不太一样：出版者改称为【主题】（Subject），订阅者改称为【观察者】（Observer）。用户可以申请成为订阅者，也可以取消；而一旦出版者有新的报纸，订阅者就可以收到。

这里出版者只有一个，而订阅者可以有多个，因此【主题】和【观察者】定义了一对多的关系。【观察者】依赖于此【主题】，只要【主题】状态一有变化，【观察者】就会被通知。根据通知的风格，【观察者】可能因新值而更新。

二、场景

下面还是通过具体场景来一步步说明。

场景：某系统中有三个部分，分别是气象站（获取实际气象数据的物理装置）、WeatherData对象（追踪来自气象站的数据，并更新布告板）和布告板（显示目前天气状况给用户看）。

气象站有很多感应装置，比如湿度感应装置、温度感应装置和气压感应装置。WeatherData对象只有一个，而布告板有多个，我们想要WeatherData对象把数据传给所有需要数据的布告板。

2.1 自定义观察者模式

首先需要定义【主题】和【观察者】接口，再让WeatherData对象实现【主题】接口，布告板实现【观察者】接口。

/**
 * 主题接口
 */
interface Subject {
    // 注册观察者
    public void registerObserver(Observer observer);
    // 删除观察者
    public void removeObserver(Observer observer);
    // 主题改变，通知所有观察者
    public void notifyObserver();
}

/**
 * 观察者接口
 */
interface Observer {
    public void update(float temperature, float humidity, float pressure);
}

/**
 * WeatherData对象（实现主题接口），只有一个
 */
class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        int i = observers.indexOf(observer);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    public void notifyObserver() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() {
        notifyObserver();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }
}

/**
 * 公告板1（实现观察者接口），可以有多个不同的公告板
 */
class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;
    private float pressure;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);  // 注册
    }

    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }

    public void display() {
        System.out.println("temperature=" + temperature +
                ", humidity=" + humidity +
                ", pressure=" + pressure);
    }
}

/**
 * 测试
 */
public class WeatherStation {
    public static void main(String[] args) {
        // 主题
        WeatherData weatherData = new WeatherData();
        // 第一个观察者
        CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
        // 多次通知
        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

观察者模式有两种方式，分别是推(push)和拉(pull)方式。

• 推(push)方式，即【主题】把数据全部推给【观察者】。上面的代码就是采用推方式。

• 拉(pull)方式，即【观察者】从【主题】拉取自己需要的数据。拉方式只需要在推方式的基础上在【主题】里加上getter方法，让【观察者】可以通过调用getter方法获取数据。

2.2 Java内置观察者模式

Java API有内置的观察者模式。java.util包内包含最基本的Observer接口与Observable类，这和我们的Subject接口与Observer接口很相似。内置的Observer接口与Observable类使用上更方便，因为许多功能都已经事先准备好了。你也可以使用推（push）或拉（pull）的方式传送数据。

2.2.1 内置观察者模式的源代码

Observale类（可观察者，即【主题】）jdk1.8源代码：

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();
            clearChanged();
        }
        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;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

有些时候【主题】改变了，但我们并不想通知【观察者】，这时就可以使用changed标志来进行判断。需要通知时就调用setChanged()方法，把changed设为true。不想通知时就调用clearChanged()方法，将changed状态设置回false。另外也有一个hasChanged()方法，告诉你changed标志的当前状态。

Observer接口（即【观察者】）jdk1.8源代码：

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

2.2.2 使用内置观察者模式

import java.util.Observable;
import java.util.Observer;

/**
 * WeatherData对象（继承内置被观察者类Observale），只有一个
 */
class WeatherData extends Observable {
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
    }

    public void measurementsChanged() {
        setChanged();
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

/**
 * 公告板1（实现观察者接口），可以有多个不同的公告板
 */
class CurrentConditionsDisplay implements Observer {
    Observable observable;
    private float temperature;
    private float humidity;
    private float pressure;

    public CurrentConditionsDisplay(Observable observable){
        this.observable = observable;
        observable.addObserver(this);  // 注册
    }

    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) observable;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            this.pressure = weatherData.getPressure();
            display();
        }
    }

    public void display() {
        System.out.println("temperature=" + temperature +
                ", humidity=" + humidity +
                ", pressure=" + pressure);
    }
}

/**
 * 测试
 */
public class WeatherStation {
    public static void main(String[] args) {
        // 主题
        WeatherData weatherData = new WeatherData();
        // 第一个观察者
        CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
        // 多次通知
        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

这里采用的是拉方式。

三、总结

观察者模式提供了一种对象设计，让主题和观察者之间松耦合。

关于观察者的一切，主题只知道观察者实现了某个接口（也就是Observer接口）。主题不需要知道观察者的具体类是谁、做了些什么或其他任何细节。

任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加观察者。事实上，在运行时我们可以用新的观察者取代现有的观察者，主题不会受到任何影响。同样的，也可以在任何时候删除某些观察者。

有新类型的观察者出现时，主题的代码不需要修改。假如我们有个新的具体类需要当观察者，我们不需要为了兼容新类型而修改主题的代码，所有要做的就是在新的类里实现此观察者接口，然后注册为观察者即可。主题不在乎别的，它只会发送通知给所有实现了观察者接口的对象。

我们可以独立地复用主题或观察者。如果我们在其他地方需要使用主题或观察者，可以轻易地复用，因为二者并非紧耦合。

改变主题或观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他们之间的接口仍被遵守，我们就可以自由地改变他们。

设计原则：为了交互对象之间的松耦合设计而努力。

---

要点：

1. 观察者模式定义了对象之间一对多的关系。
2. 主题（也就是可观察者）用一个共同的接口来更新观察者。
3. 观察者和可观察者之间用松耦合方式结合（loosecoupl-ing），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
4. 使用此模式时，你可从被观察者处推（push）或拉（pull）数据（然而，推的方式被认为更“正确”）。
5. 有多个观察者时，不可以依赖特定的通知次序。
6. Java有多种观察者模式的实现，包括了通用的java.util.Observable。
7. 要注意java.util.Observable实现上所带来的一些问题。比如Observable是一个类，Observable将关键的方法保护起来。

参考

《HeadFirst设计模式》