设计模式之观察者模式

实例

建立一个关于气象站的应用，该系统由三个部分组成，气象站（获取数据的物理装置）、WeatherData对象和布告板（显示天气状况给用户看）。

该应用有以下几个要求：
1.WeatherData类具有getter方法，可以取得三个测量值。
2.当心的测量数据备妥时，measurementsChanged（）方法就会被调用（我们不在乎此方法是如何被调用的，我们只在乎它被调用了）
3.我们需要实现三个使用天气数据的布告板，一旦WeatherData有新的测量，这些布告板必须马上更新。
4.此系统必须可扩展，让其他开发人员建立定制的布告板，用户可以随心所欲地添加或删除任何布告板。

应用观察者模式

认识观察者模式：

用一个很贴近生活的例子就是报纸杂志和订阅的关系，我订阅一家出版社的报纸，只要他们出版社出版了新的报纸，就会给我送过来，当我不想看的时候，我只要取消订阅就可以了。

简言之：

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

我们将出版者修改名称改为“主题”，订阅者改为“观察者”，可以得出下面观察者模式的类图。

定义观察者模式：

主题和观察者之间形成了一种1对多的关系，观察者依赖此主题，只要主题发生变化，观察者就会被通知。

松耦合的威力

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

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

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

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

我们可以独立地复用主题或观察者。如果我们在其他地方需要使用主题或观察者，可以轻易地复用，因为二者并非紧耦合。
改变主题或观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他们之间的接口仍被遵守，我们就可以自由地改变他们。

这里引出了一个设计原则： 为了交互对象之间的松耦合设计而努力。

根据这个原则，设计气象台的问题。

接下来用代码来实现

主题接口：

public interface Subject {
    //这两个方法都需要一个观察者作为变量，该观察者是用来注册或被删除的。
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    //当主题状态改变时，这个方法会被调用，以通知所有的观察者。
    public void notifyObservers();
}

观察者接口：

public interface Observer {
//当气象观测值改变时，主题会把这些状态值当作方法的参数，传送给观察者。
//所有的观察者都必须实现update()方法，以实现观察者接口。
    public void update(float temp, float humidity, float pressure);
}

显示接口：

public interface DisplayElement {
//DisplayElement接口只包含了一个方法，也就是display()。当布告板需要
//显示时调用此方法。
    public void display();
}

实现主题接口：

//WeatherData现在实现了Subject接口。
public class WeatherData implements Subject {
    private ArrayList observers;
    private float temperature;
    private float humidity;
    private float pressure;
    public WeatherData() {
    //ArrayList来纪录观察者，此ArrayList是在构造器中建立的
        observers = new ArrayList();
    }
    public void registerObserver(Observer o) {
    //当注册观察者时，我们只要把它加到ArrayList的后面即可。
        observers.add(o);
    }
    public void removeObserver(Observer o) {
    //同样地，当观察者想取消注册，我们把它从ArrayList中删除即可。
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }
    public void notifyObservers() {
    //在这里，我们把状态告诉每一个观察者。因为观察者都实现了update()
        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();
}

接下来建立其中一个布告板类：

//此布告板实现了Observer接口，所以可以从WeatherData对象中获得改变
//它也实现了DisplayElement接口，因为我们的API规定所有的布告板都必须实现此接口。
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    private float temperature;
    private float humidity;
    private Subject weatherData;
    public CurrentConditionsDisplay(Subject weatherData) {
    //构造器需要 weatherData对象（也就是主题）作为注册之用。
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    public void update(float temperature, float humidity, float pressure) {
    //当update()被调用时，我们把温度和湿度保存起来，然后调用display()。
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }
    public void display() {
    //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内置的观察者模式如何运作
Java内置的观察者模式运作方式，和我们在气象站中的实现类似，但有一些小差异。最明显的差异是WeatherData（也就是我们的主题）现在扩展自Observable类，并继承到一些增加、删除、通知观察者的方法（以及其他的方法）。

利用内置的支持重做气象站

首先，把WeatherData改成使用java.util.Observable

//记得要导入（import）正确的Observer/Observable。
import java.util.Observable;
import java.util.Observer;
//我们现在正在继承Observable。
public class WeatherData extends Observable {
    private float temperature;
    private float humidity;
    private float pressure;
    public WeatherData() { }
    //我们的构造器不再需要为了记住观察者们而建立数据结构了。
    public void measurementsChanged() {
    //在调用notifuObservers()之前，要先调用setChanged()来指示状态已经改变。
        setChanged();
        //注意：我们没有调用notifyObservers()传送数据对象，这表示我们采用的做法是“拉”。
        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;
    }
    //这些并不是新方法，只是因为我们要使用“拉”的做法，所以才提醒你有这些方法。察者会利用这些方法取得WeatherData对象的状态。
}

重做布告板类

import java.util.Observable;
import java.util.Observer;
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    Observable observable;
    private float temperature;
    private float humidity;
    public CurrentConditionsDisplay(Observable observable) {
    //在构造器需要一Observable当参数，并将CurrentCondi- tionsDisplay对象登记成为观察者。
        this.observable = observable;
        observable.addObserver(this);
    }
    //改变update()方法，增加Observable和数据对象作为参数。
    public void update(Observable obs, Object arg) {
        if (obs instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)obs;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
        //在 update()中，先确定可观察者属于WeatherData类型，然后利用 getter方法获取温度和湿度测量值，最后调用display()。
    }
    public void display() {
        System.out.println("Current conditions: " + temperature
        + "F degrees and " + humidity + "% humidity");
    }
}

java.util.Observable的黑暗面
使用内置的实现观察者模式的方法，违反了设计原则：针对接口编程，而非针对实现编程。因为观察者Observable是一个类，而不是一个接口，你必须设计一个类继承它。如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟Java不支持多重继承。这限制了Observable的复用潜力。

另外，Observable将关键的方法保护起来，如果你看看Observable API，你会发现setChanged()方法被保护起来了（被定义成protected）。那又怎么样呢？这意味着：除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。这个设计违反了第二个设计原则：“多用组合，少用继承”。