观察者模式

GitHub代码

场景描述：我们得到了一个类WeatherData，它可以从气象站取得数据，现在需要我们实现measurementsChanged()方法，将数据更新到相应的布告板上。

初次尝试：

public void measurementsChanged(){
    float temp = getTemperature();
    float humidity = getHumidity();
    float pressure = getPressure();
    
    currentConditionsDisplay.update(temp, humidity, pressure);
    statisticsDisplay.update(temp, humidity, pressure);
    forecastDisplay.update(temp, humidity, pressure);
}

问题所在：首先这种实现是针对具体实现编程，如果我们新增或删除布告板时，需要修改对应程序代码，这违反了我们之前提到的设计原则：针对接口编程。
其次update()方法参数相同，看起来可以提炼出一个接口。

我们尝试使用观察者模式来解决这些问题。

出版者 + 订阅者 = 观察者模式。

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

当两个对象之间松耦合，它们依然可以交互，但是不太清楚彼此的细节。
观察者模式提供了一种对象设计，让主题和观察者之间松耦合。

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

松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的相互依赖降到了最低。

根据类图，我们首先创建相应的接口

public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

public interface Observer {
    public void update(float temp, float humidity, float pressure);
}

public interface DisplayElement {
    public void display();
}

然后是具体的主题实现，它负责注册、移除和通知观察者。

/**
 * @Auther: yubt
 * @Description: push(推送数据到观察者)
 * @Date: Created in 15:48 2019/2/21
 * @Modified By:
 */
public class WeatherData implements Subject {
    private ArrayList observers;
    private float temperature;
    private float humidity;
    private float pressure;

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

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

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

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++){
            Observer observer = (Observer) observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged(){
        notifyObservers();
    }

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

接着是观察者的实现

public class CurrentConditionsDisplay implements Observer, DisplayElement {
    private float temperature;
    private float humidity;
    private Subject weatherData;

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

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

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

然后我们测试一下

public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

运行结果：

可以看到当主题类调用相关方法时，会将相应的数据推送给观察者，并由观察者展示出来。

Java是有内置的观察者模式的。分别是java.util.Observable和java.util.Observer。
同时，观察者模式存在不同的实现形式，比如上面我们的实现是通过主题向观察者进行消息的推送（push）；我们还可以通过观察者从主题拉取（pull）消息来实现观察者模式。

我们看下相关的代码实现。

/**
 * @Auther: yubt
 * @Description: pull(由观察者拉取数据)
 * @Date: Created in 16:01 2019/2/21
 * @Modified By:
 */
public 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;
    }
}

public class CurrentConditionsDisplay implements Observer, DisplayElement {
    Observable observable;
    private float temperature;
    private float humidity;

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

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

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

我们看到在WeatherData类的measurementsChanged()方法中调用了setChanged()方法，这个方法的具体作用如下。

不过，Java内置的观察者模式有它的局限。首先它是一个类，所以你必须设计一个类来继承它。如果某类想同时具有Observable类和另一个超类的行为，是无法实现的，因为Java不支持多重继承。这限制了Observable的复用潜力。
而且Observable中的setChanged()方法被保护起来了（被定义为protected）。这意味着：除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。

总结：观察者模式的使用场景是非常明显的，当存在这种通知的场景时，就可以使用观察者模式。其实现起来也并不复杂，我们只需要一个主题接口，一个观察者接口；在主题接口中，我们需要注册、删除及通知观察者的方法，而通知方法其实就是通过主题中的观察者队列调用观察者接口中的相应方法；而观察者接口中的方法就是根据需求的具体实现了。