面向对象设计模式学习总结之观察者模式（Observer）

一、

    有一个模式可以帮你的对象知悉现状，不会错过该对象感兴趣的事情。对象甚至在运行时可决定是否要继续被通知。
    有了观察者，将会消息灵通。
    
    模拟一个气象检测应用系统，系统中有三部分——气象站（获取实际气象数据的物理装置：湿度感应装置、温度感应装置、气压感应装置）、WeatherData 对象（追踪来自气象台的数据）、布告板（3个，分别是 目前状况、气象统计、天气预报）。
    
✨出版者+订阅者=观察者模式✨
    如果了解报纸的订阅是怎么回事，其实就知道观察者模式是怎么回事，只是名称不太一样，出版者改称为“主题”，订阅者改称为“观察者”。

二、定义

     观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
    主题和观察者定义了一对多的关系，观察者依赖于此主题，只要主题状态一有变化，观察者就会被通知。根据通知的风格，观察者可能因此新值而更新。

三、类图

问：
这和一对多的关系有何关联？
答：
    利用观察者模式，主题是具有状态的对象，并且可以控制这些状态，也就是说，有“一个”具有状态的主题。另一方面，观察者使用这些状态，虽然这些状态并不属于他们。有许多的观察者，依赖主题来告诉他们状态何时改变了。
    这就产生了一个关系：“一个”主题对“多个”观察者的关系。

---

问：
    其间的依赖是如何产生的？
答：
    因为主题是真正拥有数据的，观察者是主题的依赖者，在数据变化时更新，这样比起让许多对象控制同一份数据来，可以得到更干净的 OO 设计。

四、松耦合的威力

    当两个对象之间松耦合，它们依然可以交互。但是不太清楚彼此的细节。观察者模式提供了一种对象设计，让主题和观察者之间松耦合。
为什么呢？
    关于观察者的一切，主题只知道观察者实现了某个接口（也就是 Observer 接口）。主题不需要知道观察者的具体类是谁、做了些什么或其他任何细节。
    任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现 Observer 接口的对象列表，所以我们可以随时增加观察者。事实上，在运行时 ，我们可以用新的观察者取代现有的观察者，主题不会受到影响。同样的，也可以在任何时候删除某些观察者。
    有新类型的观察者出现时，主题的代码不需要修改。假如我们有个新的具体类需要当观察者，我们不需要为了兼容新类型而修改主题的代码，所有要做的 就是 在新的类里实现此观察者接口，然后注册为观察者即可。主题不在乎别的，它只会发送通知给所有实现了观察者接口的对象。
    我们可以独立地复用主题或者观察者，如果我们在其他地方需要使用主题或观察者，可以轻易地复用，因此二者并非紧耦合。
    改变主题或者观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他们之间的接口仍被遵守，我们就可以自由地改变它们。

---

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

（除此之外，观察者模式还体现了以下设计原则：
① 找出程序中会变化的方面，然后将其和固定不变的方面相分离。
    在观察者模式中，会改变的是主题的状态，以及观察者的数目和类型。用这个模式，可以改变依赖于主题状态的对象，却不必改变主题，这叫提前规划。）
② 针对接口编程，不针对实现编程。
    主题 与 观察者 都使用接口：观察者利用主题的接口向主题注册，而主题利用观察者接口通知观察者。这样可以让两者之间运作正常，又同时具有松耦合的优点。
③ 多用组合，少用继承。
    观察者模式利用 “组合” 将许多观察者组合进主题中。对象之间的这种关系不是通过继承产生的，而是在运行时利用组合的方式产生的。

---

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

五、实现一个气象站

实现主题接口：

package Observer;

import java.util.ArrayList;
import Observer.Observer;

public class WeatherData implements Subject
{
    
    //用于记录观察者
    private ArrayList observers;
    //温度
    double temperature;
    //湿度
    double humidity;
    //气压
    double pressure;

    public WeatherData()
    {
        //用于记录观察者
        observers=new ArrayList();
    }

    //温度
    public double getTemperature() {
        return temperature;
    }

    public void setTemperature(double temperature) {
        this.temperature = temperature;
    }
//湿度
    public double getHumidity() {
        return humidity;
    }

    public void setHumidity(double humidity) {
        this.humidity = humidity;
    }
//气压
    public double getPressure() {
        return pressure;
    }

    public void setPressure(double pressure) {
        this.pressure = pressure;
    }


    //一旦气象测量更新，此方法会被调用
    //它需要更新目前状况、气象统计、天气预报的显示布告板
    //当新的测量数据备妥时，该方法就会被调用
    public void measurementsChanged()
    {
    notifyObservers();
    }


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

    }

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


    public void notifyObservers() {
for(int i=0;i<observers.size();i++)
{
    //把状态告诉每一个观察者。因为观察者都实现了update()
    Observer observer= (Observer) observers.get(i);
    observer.update(temperature,humidity,pressure);
}
    }
}

建立布告板：

package Observer;

//布告板实现了 Observer 接口，所以可以从 WeatherData 对象中获取改变
//也实现了 DisplayElement 
public class CurrentConditionsDisplay implements Observer,DisplayElement {
    private float temperature;
    private double humidity;
    private Subject weatherData;

    //构造方法需要 weatherData对象，做注册用
    public CurrentConditionsDisplay(Subject weatherData)
    {
        this.weatherData=weatherData;
        weatherData.registerObserver(this);
    }
    
    public void update(double temp, double humidity, double pressure) {
this.temperature=temperature;
this.humidity=humidity;
display();
    }
    
    //显示最近的温度和湿度
    public void display() {
        System.out.println("Current conditions:"+temperature+"F degrees and"+humidity+"% humidity");
    }
}

启动气象站：

package Observer;

//布告板实现了 Observer 接口，所以可以从 WeatherData 对象中获取改变
//也实现了 DisplayElement 
public class CurrentConditionsDisplay implements Observer,DisplayElement {
    private float temperature;
    private double humidity;
    private Subject weatherData;

    //构造方法需要 weatherData对象，做注册用
    public CurrentConditionsDisplay(Subject weatherData)
    {
        this.weatherData=weatherData;
        weatherData.registerObserver(this);
    }
    
    public void update(double temp, double humidity, double pressure) {
this.temperature=temperature;
this.humidity=humidity;
display();
    }
    
    //显示最近的温度和湿度
    public void display() {
        System.out.println("Current conditions:"+temperature+"F degrees and"+humidity+"% humidity");
    }
}

---

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

---

六、Java 内置的观察者模式如何运作

    现在改变一下，让 WeatherData 扩展自 Observable 类，并继承到一些增加、删除、通知观察者的方法（以及其他的方法）。
如何把对象变成观察者
    实现观察者接口 (java.util.Observer)，然后调用任何 Observable 对象的 addObserver() 方法，不想当观察者时，调用 deleteObserver() 方法就可以了。
观察者要如何送出通知
    首先，需要利用扩展 java.util.Observable 接口产生 “可观察类”，然后需要两个步骤：
① 先调用 setChanged() 方法，标记状态已经改变的事实。
② 然后调用两种 notifyObserver() 方法中的一个
notifyObservers() 或 notifyObservers(Object arg)
    arg:当通知时，此版本可以传送任何的数据对象给每一个观察者
观察者如何接收通知
    同以前一样，观察者实现了更新的方法，但是方法的签名不太一样。

update(Observable o,Object arg)

o:主题本身当作第一个变量，好让观察者知道是哪个主题通知它的。
arg:这正是传入 notifyObservers(Object arg) 的数据对象，如果没有说明则为空。
    如果想“推” push 数据给观察者，可以把数据当作数据对象传送给 notifyObservers(arg) 方法。否则，观察者就必须从可观察者对象中 “拉” pull 数据。
    在讨论如何 拉数据之前，先来看看 setChanged() 方法：

protected synchronized void setChanged() {
        changed = true;
    }

    该方法用来标记状态已经改变的事实。 好让 notifyObservers() 知道 当它被调用时应该更新观察者。如果调用 notifyObservers() 之前没有先调用 setChanged()，观察者就 “不会” 被通知。来看看 Observable 内部：

 public void notifyObservers() {
        notifyObservers(null);
    }

public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            //只在 changed 被标记为 true 时通知观察者
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

  //在通知观察者后，把 changed 标志改回 false
    protected synchronized void clearChanged() {
        changed = false;
    }

    这样做有其必要性，setChanged() 方法可以在更新观察者时，有更多的弹性，可以更适当地通知观察者。比如说，如果没有 setChanged() 方法，我们的气象站测量是如此敏锐，以致于温度计读数每十分之一度就会更新，这会造成 WeatherData 对象持续不断地通知观察者，我们并不希望看到这样的事情发生，如果我们希望半度以上才更新，就可以在温度差距达到半度时，调用 setChanged() ，进行有效的更新。
    

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

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

package Observer;

/*
继承 Observable ，就不再需要追踪观察者了，也不需要管理注册与删除
（让超类代替即可）。所以我们把注册、添加、通知的相关代码剔除
 */

public class WeatherData extends Observable
{
    //温度
    double temperature;
    //湿度
    double humidity;
    //气压
    double pressure;

    //因为要使用“拉”的做法，所以才需要提供 gettter 方法，
    //观察者会利用这些方法取得 WeatherData 对象的状态
    public double getTemperature() {
        return temperature;
    }

    public double getHumidity() {
        return humidity;
    }

    public double getPressure() {
        return pressure;
    }

    public WeatherData()
    {}

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

    public void measurementsChanged()
    {
    //没有调用 notifyObservers() 传送数据对象，这表示我们采用的做法是“拉”
    //在调用notifyObserver() 之前，要先调用setChanged() 来指示状态已经改变
    setChanged();
    notifyObservers();
    }
}

重写 CurrentConditionsDisplay：

package Observer;

import java.util.Observable;
import java.util.Observer;
//布告板实现了 Observer 接口，所以可以从 WeatherData 对象中获取改变
//也实现了 DisplayElement
public class CurrentConditionsDisplay implements Observer,DisplayElement {
    Observable observable;
    private float temperature;
    private double humidity;
  
/*
    //构造方法需要 weatherData对象，做注册用
    public CurrentConditionsDisplay(Subject weatherData)
    {
        this.weatherData=weatherData;
        weatherData.registerObserver(this);
    }
*/
public CurrentConditionsDisplay(Observable observable)
{
    this.observable=observable;
    observable.addObserver(this);
}

    /*
    在 update 中，先确定可观察者属于 WeatherData 类型，
    然后利用 getter 方法获取温度和湿度测量值，
    最后调用 display
     */
    public void update(Observable o, Object arg) {
        if(o instanceof WeatherData)
        {WeatherData weatherData= (WeatherData) o;
        this.temperature= (float) weatherData.getTemperature();
        this.humidity=weatherData.getHumidity();
        display();
        }
    }
    //显示最近的温度和湿度
    public void display() {
        System.out.println("Current conditions:"+temperature+"F degrees and"+humidity+"% humidity");
    }
}

不要依赖于观察者被通知的次序
    java.util.Observable 实现了它的 notifyObservers() 方法，这导致了通知观察者的次序不同于我们之前的次序。谁也没有错，只是双方选择不同的方式实现罢了。
    但是可以确定的是，如果我们的代码依赖这样的次序，就是错的。为什么呢？因为一旦观察者/ 可观察者 的实现有所改变，通知次序就会改变，很可能就会产生错误的结果，而这不是我们所认为的松耦合。
    

八、java.util.Observable 的黑暗面

    可观测者是一个 “类”，（Java 毕竟不支持多重继承，这就有所限制了）而不是一个 “接口”，更糟的是，它甚至没有实现一个接口。不幸的是，java.util.Observable 的实现有许多问题，限制了它的使用和复用。这并不是说它没有提供有用的功能，只是提醒一下这个事实。