让你的对象知悉现况

Joe：喂，Jerry，我正在通知大家，模式小组会议改到周六晚上，这次要讨论的是观察者模式，这个模式最棒了！超级棒！你一定要来呀，Jerry。

有趣的事情发生时，可千万别错过了！有一个模式可以帮你的对象知悉现况，不会错过该对象感兴趣的事。对象甚至在运行时可决定是否要继续被通知。观察者模式是JDK中使用最多的模式之一，非常有用。我们也会一并介绍一对多关系，以及松耦合（对，没错,我们说耦合）。有了观察者，你将会消息灵通。

1.气象观测站

恭喜你！你的团队刚刚赢得一纸合约，负责建立Weather-O-Rama公司的下一代气象站——Internet气象观测站。

Weather-O-Rama气象站
100 Main Street
Tornado Alley, OK 45021

工作合约

恭喜贵公司获选为敝公司建立下一代Internet气象观测站！该气象站必须建立在我们专利申请中的WeatherData对象上，由WeatherData对象负责追踪目前的天气状况（温度、湿度、气压）。我们希望贵公司能建立一个应用，有三种布告板，分别显示目前的状况、气象统计及简单的预报。当WeatherObject对象获得最新的测量数据时，三种布告板必须实时更新。

而且，这是一个可以扩展的气象站，Weather-O-Rama气象站希望公布一组API，好让其他开发人员可以写出自己的气象布告板，并插入此应用中。我们希望贵公司能提供这样的API。

Weather-O-Rama气象站有很好的商业营运模式：一旦客户上钩，他们使用每个布告板都要付钱。最好的部分就是，为了感谢贵公司建立此系统，我们将以公司的认股权支付你。

我们期待看到你的设计和应用的alpha版本。

真挚的。

Johnny Hurricane——Weather-O-Rama气象站执行长
附注：我们正通宵整理WeatherData源文件给你们。

1.1 气象监测应用的概况

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

WeatherData对象知道如何跟物理气象站联系，以取得更新的数据。WeatherData对象会随即更新三个布告板的显示：目前状况（温度、湿度、气压）、气象统计和天气预报。

如果我们选择接受这个项目，我们的工作就是建立一个应用，利用WeatherData对象取得数据，并更新三个布告板：目前状况、气象统计和天气预报。

1.2 瞧一瞧刚送到的WeatherData类

如同他们所承诺的，隔天早上收到了WeatherData源文件，看了一下代码，一切都很直接：

我们目前知道些什么？

WeatherData类具有getter方法，可以取得三个测量值：温度、湿度与气压。

• getTemperature()
• getHumidity()
• getPressure()

当新的测量数据备妥时，measurementsChanged()方法就会被调用（我们不在乎此方法是如何被调用的，我们只在乎它被调用了）。

• measurementsChanged()

我们需要实现三个使用天气数据的布告板：“目前状况”布告、“天气统计”布告、“天气预报”布告。一旦WeatherData有新的测量，这些布告必须马上更新。

 

先看一个错误示范

这是第一个可能的实现：我们依照Weather-O-Rama气象站开发人员的暗示，在measurementsChanged()方法中添加我们的代码：

public class WeatherData {
    // 实例变量声明

    public void measurementsChanged(){

        //调用WeatherData的三个getXxx()方法，以取得最近的测量值。这些getXxx()方法已经实现好了。
        float temp = getTemperature();
        float humidity = getHumidity();
        float pressure = getPressure();

        //现在，更新布告板……调用每个布告板更新显示，传入最新的测量。
        currentConditionsDisplay.update(temp,humidity,pressure);
        statisticsDisplay.update(temp,humidity,pressure);
        statisticsDisplay.update(temp,humidity,pressure);
    }

    // 这里是其他WeatherData方法
}

我们的实现有什么不对？

    public void measurementsChanged(){

        float temp = getTemperature();
        float humidity = getHumidity();
        float pressure = getPressure();

        //改变的地方，需要封装起来。
        //至少，这里看起来像是一个统一的接口，
        //布告板的方法名称都是update()，参数都是温度、湿度、气压
        //针对具体实现编程，会导致我们以后在增加或删除布告板时必须修改程序。
        currentConditionsDisplay.update(temp,humidity,pressure);
        statisticsDisplay.update(temp,humidity,pressure);
        statisticsDisplay.update(temp,humidity,pressure);
    }

我们现在就来看观察者模式，然后再回来看看如何将此模式应用到气象观测站。

2. 认识观察者模式

我们看看报纸和杂志的订阅是怎么回事：

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

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

如果你了解报纸的订阅是怎么回事，其实就知道观察者模式是怎么回事，只是名称不太一样：出版者改称为“主题”（Subject），订阅者改称为“观察者”（Observer）。

让我们来看得更仔细一点：

2.1 观察者模式的一天

鸭子对象过来告诉主题，它想当一个观察者。

鸭子其实想说的是：我对你的数据改变感兴趣，一有变化请通知我。

鸭子对象现在已经是正式的观察者了。

鸭子静候通知，等待参与这项伟大的事情。一旦接获通知，就会得到一个整数。

主题有了新的数据值！

现在鸭子和其他所有观察者都会收到通知：主题已经改变了。

老鼠对象要求从观察者中把自己除名。

老鼠已经观察此主题太久，厌倦了，所以决定不再当个观察者。

老鼠离开了！

主题知道老鼠的请求之后，把它从观察者中除名。

主题有一个新的整数

除了老鼠之外,每个观察者都会收到通知，因为它已经被除名了。嘘！不要告诉别人，老鼠其实心中暗暗地怀念这些整数，或许哪天又会再次注册，回来继续当观察者呢！

2.2 五分钟短剧：观察的主题

在今天的讽刺短剧中，有两个后泡沫时期的软件工程师，遇到一个真正的猎头……

一号软件开发人员Ron：我是Ron，我正在寻找一个Java程序员的工作，我有五年经验，而且……

猎头/主题：好的，宝贝！我把你和其他人都加入我的Java程序员清单中，不要打电话给我，我会打电话给你。

二号软件开发人员Jill：你好，我是Jill。我写过很多EJB系统，我对Java程序员的工作感兴趣。

主题：我把你加入我的清单中。你会和其他人一样收到我的通知。

其间，Ron和Jill继续过自己的日子，如果Java工作来了，他们会接到通知，毕竟，他们是观察者嘛！

主题：嗨！观察者，“JavaBeans反斗城”需要一个Java程序员，快去应征，别搞砸了！哇哈哈！把介绍费汇到我的银行户头，宝贝！

一号软件开发人员Ron：谢谢，我立刻把我的简历发过去。

二号软件开发人员Jill：这个家伙根本是个混蛋，谁需要他呀！我要自己去找工作。

Jill自己找到工作了！

二号软件开发人员Jill：你可以把我从名单中删除，我自己找到工作了！

主题：MMP！你给我记着。我会找机会整你，你别想在本村混了。我立刻把你从名单中删除！！！

两周后……

Jill热爱她的现状，她不再是观察者了。她还因为签约获得了一笔奖金，因为公司不用拨出一大笔钱给猎头。

但是，我们亲爱的Ron，又如何了？我们听说他设局把原来的猎头搞得毫无招架之力。他不只是一个观察者，也有了自己的求职者清单，只要付一笔钱给猎头，就可从其他求职者赚取更多钱。Ron既是一个主题，也是一个观察者，集两种角色于一身。

2.3 定义观察者模式

当你试图勾勒观察者模式时，可以利用报纸订阅服务，以及出版者和订阅者比拟这一切。

在真实的世界中，你通常会看到观察者模式被定义成：

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

观察者模式定义了一系列对象之间的一对多关系。当一个对象改变状态，其他依赖者都会收到通知。

让我们看看这个定义，并和之前的例子做个对照：

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

稍后你会看到，实现观察者模式的方法不只一种，但是以包含Subject与Observer接口的类设计的做法最常见。

让我们快来看看吧……

2.4 松耦合——定义观察者模式：类图

• 问：这和一对多的关系有何关联？
• 答：利用观察者模式，主题是具有状态的对象，并且可以控制这些状态。也就是说，有“一个”具有状态的主题。另一方面，观察者使用这些状态，虽然这些状态并不属于他们。有许多的观察者，依赖主题来告诉他们状态何时改变了。这就产生一个关系：“一个”主题对“多个”观察者的关系。
• 问：其间的依赖是如何产生的？
• 答：因为主题是真正拥有数据的人，观察者是主题的依赖者，在数据变化时更新，这样比起让许多对象控制同一份数据来，可以得到更干净的的OO设计。

2.5 松耦合的威力

当两个对象之间松耦合，它们依然可以交互，但是不太清楚彼此的细节。

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

为什么呢？

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

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

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

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

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

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

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

2.6 使用观察者模式重新设计气象站

回到气象站项目，你的队友们已经开始全面思考这个问题了……

Sue：那么，我们该如何建立这个系统？

Mary：这个嘛！使用观察者模式啰！

Sue：是的……但是如何应用？

Mary：唔，我们再看一下定义好了：

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

Mary：当你思考这个定义时，你会发现很有道理。我们的WeatherData类正是此处所说的“一”，而我们的“多”正是使用天气观测的各种布告板。

Sue：没错。WeatherData对象的确是有状态，包括了温度、湿度、气压，而这些值都会改变。

Mary：对呀！而且，当这些观测值改变时，必须通知所有的布告板，好让它们各自做出处理。

Sue：好棒！我现在知道如何将观察者模式应用在气象站问题上了。

Mary：还有一些问题有待理清，我现在还不太了解它们的解决方法。

Sue：什么问题？

Mary：其中一个问题是，我们如何将气象观测值放到布告板上。

Sue：回头去看看观察者模式的图，如果我们把WeatherData对象当作主题，把布告板当作观察者，布告板为了取得信息，就必须先向WeatherData对象注册。对不对？

Mary：是的……一旦WeatherData知道有某个布告板的存在，就会适时地调用布告板的某个方法来告诉布告板观测值是多少。

Sue：我们必须记得，每个布告板都有差异，这也就是为什么我们需要一个共同的接口的原因。尽管布告板的类都不一样，但是它们都应该实现相同的接口，好让WeatherData对象能够知道如何把观测值送给它们。

Mary：我懂你的意思。所以每个布告板都应该有一个大概名为update()的方法，以供WeatherData对象调用。

Sue：而这个update()方法应该在所有布告板都实现的共同接口里定义。

看看这个设计图：

2.7 实现气象站

依照两页前Mary和Sue的讨论，以及上一页的类图，我们要开始实现这个系统了。稍后，你将会看到Java为观察者模式提供了内置的支持，但是，我们暂时不用它，而是先自己动手。虽然，某些时候可以利用Java内置的支持，但是有许多时候，自己建立这一切会更具弹性（况且建立这一切并不是很麻烦）。所以，让我们从建立接口开始吧：

package com.zjwave.pattern.observer;

public interface Subject {

    /**
     * 这两个方法都需要一个观察者作为变量，该观察者是用来注册或被删除的。
     * @param o
     */
    void registerObserver(Observer o);
    void removeObserver(Observer o);

    /**
     * 当主题状态改变时，这个方法会被调用，以通知所有的观察者。
     */
    void notifyObservers();
}

package com.zjwave.pattern.observer;

public interface Observer {

    /**
     * 所有的观察者都必须实现update()方法，以实现观察者接口。在这里，
     * 我们按照Mary和Sue的想法把观测值传入观察者中。
     * 当气象观测值改变时，主题会把这些状态值当作方法的参数，传送给观察者。
     * @param temp
     * @param humidity
     * @param pressure
     */
    void update(float temp, float humidity, float pressure);

}

package com.zjwave.pattern.observer;

public interface DisplayElement {

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

Mary和Sue认为：把观测值直接传入观察者中是更新状态的最直接的方法。你认为这样的做法明智吗？暗示：这些观测值的种类和个数在未来有可能改变吗？如果以后会改变，这些变化是否被很好地封装？或者是需要修改许多代码才能办到？关于将更新的状态传送给观察者，你能否想到更好的方法解决此问题？别担心，在我们完成第一次实现后，我们会再回来探讨这个设计决策。

在WeatherData中实现主题接口：

还记得我们在本文一开始的地方就试图实现WeatherData类吗？你可以去回顾一下。现在，我们要用观察者模式实现……

package com.zjwave.pattern.observer;

import java.util.ArrayList;
import java.util.List;

/**
 * WeatherData现在实现了Subject接口。
 */
public class WeatherData implements Subject {

    /**
     * 我们加上一个ArrayList来纪录观察者，
     * 此ArrayList是在构造器中建立的。
     */
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

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


    /**
     * 当注册观察者时，我们只要把它加到ArrayList的后面即可。
     *
     * @param o
     */
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    /**
     * 同样地，当观察者想取消注册，我们把它从ArrayList中删除即可。
     *
     * @param o
     */
    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    /**
     * 有趣的地方来了！在这里，我们把状态告诉每一个观察者。
     * 因为观察者都实现了update()，所以我们知道如何通知它们。
     */
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    /**
     * 当从气象站得到更新观测值时，我们通知观察者。
     */
    public void measurementsChanged() {
        notifyObservers();
    }

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

    // WeatherData的其他方法
}

现在，我们来建立布告板吧！

我们已经把WeatherData类写出来了，现在轮到布告板了。Weather-O-Rama气象站订购了三个布告板：目前状况布告板、统计布告板和预测布告板。

package com.zjwave.pattern.observer;

/**
 * 此布告板实现了Observer接口，所以可以从WeatherData对象中获得改变。
 * 它也实现了DisplayElement接口,因为我们的API规定所有的布告板都必须实现此接口。
 */
public class CurrentConditionsDisplay implements Observer,DisplayElement {

    private float temperature;
    private float humidity;
    private Subject weatherData;

    /**
     * 构造器需要 weatherData对象（也就是主题）作为注册之用。
     * @param weatherData
     */
    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    /**
     * display()方法就只是把最近的温度和湿度显示出来。
     */
    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }

    /**
     * 当update()被调用时，我们把温度和湿度保存起来，然后调用display()。
     * @param temp
     * @param humidity
     * @param pressure
     */
    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        display();
    }
}

package com.zjwave.pattern.observer;

/**
 * 布告板StatisticsDisplay：显示最小、平均和最大的温度观测值
 */
public class StatisticsDisplay implements Observer, DisplayElement {

    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;//记录观测的次数以便计算平均温度值
    private Subject weatherData;

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

    @Override
    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        tempSum += temp;
        numReadings++;
        if (temp > maxTemp) {
            maxTemp = temp;
        }
        if (temp < minTemp) {
            minTemp = temp;
        }
        display();
    }
}

package com.zjwave.pattern.observer;

/**
 * 布告板ForecastDisplay：天气预报
 */
public class ForecastDisplay implements Observer, DisplayElement {

    private float currentPressure = 29.92f;
    private float lastPressure;
    private Subject weatherData;

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

    @Override
    public void display() {
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        lastPressure = currentPressure;
        currentPressure = pressure;
        display();
    }
}

 

• 问：update()是最适合调用display()的地方吗？
• 答：在这个简单的例子中，当值变化的时候调用display()，是很合理的。然而，你是对的，的确是有很多更好的方法来设计显示数据的方式。当我们谈到MVC（Model-View-Controller）模式时会再作说明。
• 问：为什么要保存对Subject的引用呢？构造完后似乎用不着了呀？
• 答：的确如此，但是以后我们可能想要取消注册，如果已经有了对Subject的引用会比较方便。

启动气象站

气象站已经完成得差不多了，我们还需要一些代码将这一切连接起来。这是我们的第一次尝试，稍后我们会再回来确定每个组件都能通过配置文件来达到容易“插拔”。现在开始测试吧：

package com.zjwave.pattern.observer;

public class WeatherStation {
    public static void main(String[] args) {
        //首先，建立一个WeatherData对象。
        WeatherData weatherData = new WeatherData();

        //建立三个布告板，并把WeatherData对象传给它们。
        CurrentConditionsDisplay conditionsDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        //模拟新的气象测量。
        weatherData.setMeasurements(80,65,30.4f);
        weatherData.setMeasurements(82,70,29.2f);
        weatherData.setMeasurements(78,90,29.2f);
    }
}

运行程序，让观察者模式表演魔术。

2.8 围炉夜话：主题与观察者

今夜话题：主题和观察者就使观察者获得状态信息的正确方法发生了争吵。

主题：我很高兴，我们终于有机会面对面聊天了。

观察者：是这样吗？我以为你根本不在乎我们这群观察者呢。

主题：唉呀！我把该做的事都做到了，不是吗？我总是会通知你们发生什么事了……我虽然不知道你们是谁，但这不意味着我不在乎你们。况且，我知道关于你们的一件重要的事：你们实现了Observer接口。

观察者：是呀，但这只是关于我的一小部分罢了！无论如何，我对你更了解……

主题：是吗？说来听听！

观察者：嗯！你总是将你的状态传给我们，所以我们可以知道你内部的情况。有时候，这很烦人的……

主题：拜托，我必须主动送出我的状态和通知给大家，好让你们这些懒惰的观察者知道发生什么事了。

观察者：咳！等等。我说主题先生，首先，我们并不懒，在你那些“很重要”通知的空档中，我们还有别的事要做。另外，为何由你主动送数据过来，而不是让我们主动去向你索取数据？

主题：嗯……这样或许也行，只是我必须因此门户大开，让你们全都可以进来取得你们需要的状态，这样太危险了。我不能让你们进来里面大肆挖掘我的各种数据。

观察者：你何不提供一些公开的getter方法，让我们“拉”走我们需要的状态？

主题：是的，我可以让你们“拉”走我的状态，但是你不觉得这样对你们反而不方便吗？如果每次想要数据时都来找我，你可能要调用很多次才能收集齐全你所要的状态。这就是为什么我更喜欢“推”的原因，你们可以在一次通知中一口气得到所有东西。

观察者：死鸭子嘴硬！观察者种类这么多，你不可能事先料到我们每个人的需求，还是让我们直接去取得我们需要的状态比较恰当，这样一来，如果我们有人只需要一点点数据，就不会被强迫收到一堆数据。这么做同时也可以在以后比较容易修改。比方说，哪一天你决定扩展功能，新增更多的状态，如果采用我建议的方式，你就不用修改和更新对每位观察者的调用，只需改变自己来允许更多的getter方法来取得新增的状态。

主题：是的。两种做法都有各自的优点。我注意到Java内置的Observer 模式两种做法都支持。

观察者：真的吗？我们得去瞧瞧……

主题：太好了，或许我会看到一个“拉”的好例子，因而改变我的想法。

观察者：什么？我们会有意见相同的一天？不会吧！

3. 使用Java内置的观察者模式

到目前为止，我们已经从无到有地完成了观察者模式，但是，Java API有内置的观察者模式。java.util包（package）内包含最基本的Observer接口与Observable类，这和我们的Subject接口与Observer接口很相似。Observer接口Observable类使用上更方便，因为许多功能都已经事先准备好了。你甚至可以使用推（push）或拉（pull）的方式传送数据，稍后就会看到这样的例子。

有了Java内置的支持，你只需要扩展（继承）Observable，并告诉它何时该通知观察者，一切就完成了，剩下的事API会帮你做。

为了更了解java.uitl.Observer和java.util.Observable，看看下面的图，这是修改后的气象站OO设计。

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

Java内置的观察者模式运作方式，和我们在气象站中的实现类似，但有一些小差异。最明显的差异是WeatherData（也就是我们的主题）现在扩展自Observable类，并继承到一些增加、删除、通知观察者的方法（以及其他的方法）。Java版本的用法如下：

如何把对象变成观察者……

如同以前一样，实现观察者接口（java.uitl.Observer），然后调用任何Observable对象的addObserver()方法。不想再当观察者时，调用deleteObserver()方法就可以了。

可观察者要如何送出通知……

首先，你需要利用扩展java.util.Observable接口产生“可观察者”类，然后，需要两个步骤：

• 先调用setChanged()方法，标记状态已经改变的事实。
• 然后调用两种notifyObservers()方法中的一个：

notifyObservers()
//当通知时，此版本可以传送任何的数据对象给每一个观察者。
notifyObservers(Object arg)

观察者如何接收通知……

同以前一样，观察者实现了更新的方法，但是方法的签名不太一样：

//主题本身当作第一个变量，好让观察者知道是哪个主题通知它的。
//这正是传入notifyObservers()的数据对象。如果没有说明则为空。
update(Observable o, Object arg)

如果你想“推”（push）数据给观察者，你可以把数据当作数据对象传送给notifyObservers(arg)方法。否则，观察者就必须从可观察者对象中“拉”（pull）数据。如何拉数据？我们再做一遍气象站，你很快就会看到。

萌新：等等，在开始讨论拉数据之前，我想知道setChanged()方法是怎么一回事？为什么以前不需要它？

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

Observable类的伪代码：

//setChanged()方法把changed标志设为true。
setChanged() {
    changed = true
}

//notifyObservers()只会在changed标为“true”时通知观察者。
notifyObservers(Object arg) {
    if (changed) {
        for every observer on the list {
            call update (this, arg)
        }
        //在通知观察者之后，把changed标志设回false。
        changed = false
    }
}

notifyObservers() {
    notifyObservers(null)
}

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

你也许不会经常用到此功能，但是把这样的功能准备好，当需要时马上就可以使用。总之，你需要调用setChanged()，以便通知开始运转。如果此功能在某些地方对你有帮助，你可能也需要clearChanged()方法，将changed状态设置回false。另外也有一个hasChanged()方法，告诉你changed标志的当前状态。

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

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

package com.zjwave.pattern.observer.javaobserver;

import java.util.Observable;

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

    private float temperature;
    private float humidity;
    private float pressure;

    /**
     * 我们的构造器不再需要为了记住观察者们而建立数据结构了。
     */
    public WeatherData() {
    }

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

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

    /**
     * 这些并不是新方法，只是因为我们要使用“拉”的做法，
     * 所以才提醒你有这些方法。观察者会利用这些方法取得WeatherData对象的状态。
     * @return
     */
    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

现在，让我们重做三个布告板：

package com.zjwave.pattern.observer.javaobserver;

import com.zjwave.pattern.observer.DisplayElement;

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

/**
 * 我们现在正在实现java.util.Observer接口。
 */
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    Observable observable;
    private float temperature;
    private float humidity;

    /**
     * 现在构造器需要一Observable当参数，并将
     * CurrentConditionsDisplay对
     * 象登记成为观察者。
     * @param observable
     */
    public CurrentConditionsDisplay(Observable observable) {
        this.observable = observable;
        observable.addObserver(this);
    }

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

    /**
     * 改变update()方法，增加Observable和数据对象作为参数。
     * @param o
     * @param arg
     */
    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof WeatherData){
            //在update()中，先确定可
            //观察者属于WeatherData类型，
            //然后利用 getter方法获取温度和湿度测量值，
            //最后调用display()。
            WeatherData weatherData = (WeatherData) o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }
}

package com.zjwave.pattern.observer.javaobserver;

import com.zjwave.pattern.observer.DisplayElement;

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


public class StatisticsDisplay implements Observer, DisplayElement {

    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;
    Observable observable;

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

    @Override
    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }


    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            float temp = weatherData.getTemperature();
            tempSum += temp;
            numReadings++;
            if (temp > maxTemp) {
                maxTemp = temp;
            }
            if (temp < minTemp) {
                minTemp = temp;
            }
            display();
        }
    }
}

package com.zjwave.pattern.observer.javaobserver;

import com.zjwave.pattern.observer.DisplayElement;

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

public class ForecastDisplay implements Observer, DisplayElement {

    private float currentPressure = 29.92f;
    private float lastPressure;
    Observable observable;

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

    @Override
    public void display() {
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }

    @Override
    public void update(Observable o, Object arg) {
        lastPressure = currentPressure;
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            currentPressure = weatherData.getPressure();
            display();
        }
    }
}

让我们运行新的代码，以确定它是对的……

嗯！你注意到差别了吗？再看一次……

你会看到相同的计算结果，但是奇怪的地方在于，文字输出的次序不一样。怎么会这样呢？在继续之前，请花一分钟的时间思考……

不要依赖于观察者被通知的次序

java.uitl.Observable实现了它的notifyObservers()方法，这导致了通知观察者的次序不同于我们先前的次序。谁也没有错，只是双方选择不同的方式实现罢了。

但是可以确定的是，如果我们的代码依赖这样的次序，就是错的。为什么呢？因为一旦观察者/可观察者的实现有所改变，通知次序就会改变，很可能就会产生错误的结果。这绝对不是我们所认为的松耦合。

难道java.util.Observable违反了我们的OO设计原则：针对接口编程，而非针对实现编程？

java.util.Observable的黑暗面

是的，你注意到了！如同你所发现的，可观察者是一个“类”而不是一个“接口”，更糟的是，它甚至没有实现一个接口。不幸的是，java.util.Observable的实现有许多问题，限制了它的使用和复用。这并不是说它没有提供有用的功能，我们只是想提醒大家注意一些事实。

Observable是一个类

你已经从我们的原则中得知这不是一件好事，但是，这到底会造成什么问题呢？

首先，因为Observable是一个“类”，你必须设计一个类继承它。如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟Java不支持多重继承。这限制了Observable的复用潜力（而增加复用潜力不正是我们使用模式最原始的动机吗？）。

再者，因为没有Observable接口，所以你无法建立自己的实现，和Java内置的Observer API搭配使用，也无法将java.util的实现换成另一套做法的实现（比方说，

Observable将关键的方法保护起来

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

做什么呢？

如果你能够扩展java.util.Observable，那么Observable“可能”可以符合你的需求。否则，你可能需要像本文开头的做法那样自己实现这一整套观察者模式。不管用哪一种方法，反正你都已经熟悉观察者模式了，应该都能善用它们。

3.3 在JDK中，还有哪些地方可以找到观察者模式

在JDK中，并非只有在java.util中才能找到观察者模式，其实在JavaBeans和Swing中，也都实现了观察者模式。现在，你已经具备足够的能力来自行探索这些API，但是我们还是在此稍微提一个简单的Swing例子，让你感受一下其中的乐趣。

如果你对JavaBeans里的观察者模式感到好奇，可以查一下PropertyChangeListener接口。

背景介绍……

让我们看看一个简单的Swing API：JButton。如果你观察一下JButton的超类AbstractButton，会看到许多增加与删除倾听者（listener）的方法，这些方法可以让观察者感应到Swing组件的不同类型事件。比方说：ActionListener让你“倾听”可能发生在按钮上的动作，例如按下按钮。你可以在Swing API中找到许多不同类型的倾听者。

一个小的、改变生活的程序

我们的程序很简单，你有一个按钮，上面写着“Should I do it?”（我该做吗？）。当你按下按钮，倾听者（观察者）必须回答此问题。我们实现了两个倾听者，一个是天使（AngelListener），一个是恶魔（DevilListener）。程序的行为如下：

代码是这样的……

这个改变生活的程序需要的代码很短。我们只需要建立一个JButton对象，把它加到JFrame，然后设置好倾听者就行了。我们打算用内部类（innerAclass）作为倾听者类（这样的技巧在Swing中很常见）。

package com.zjwave.pattern.observer;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SwingObserverExample {
    JFrame frame;

    public static void main(String[] args) {
        SwingObserverExample example = new SwingObserverExample();
        example.go();
    }


    public void go(){
        frame = new JFrame();
        //制造出两个倾听者（观察者），一个天使，一个恶魔。
        JButton button = new JButton("Should I do it?");
        button.addActionListener(new AngelListener());
        button.addActionListener(new DevilListener());
        frame.getContentPane().add(BorderLayout.CENTER,button);
        // 在这里设置frame属性
    }


    class AngelListener implements ActionListener{

        /**
         * 当主题（JButton）的状态改变时，在本例中，
         * 不是调用update()，而是调用actionPerformed()。
         * @param e
         */
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Don't do it, you might regret it!");
        }
    }

    class DevilListener implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Come on, do it!");
        }
    }
    
}

4.总结

本文我们学习了一个新的模式——观察者模式，以松耦合方式在一系列对象之间沟通状态。我们目前还没看到观察者模式的代表人物——MVC，以后就会看到了。

现在你的设计箱内又多了一些东西……

OO基础：

• 抽象

OO原则：

• 封装变化
• 多用组合，少用继承
• 针对接口编程，不针对实现编程
• 为交互对象之间的松耦合设计而努力

本文要点：

• 观察者模式定义了对象之间一对多的关系。
• 主题（也就是可观察者）用一个共同的接口来更新观察者
• 观察者和可观察者之间用松耦合方式结合（loosecoupling），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
• 使用此模式时，你可从被观察者处推（push）或拉（pull）数据（然而，推的方式被认为更“正确”）。
• 有多个观察者时，不可以依赖特定的通知次序。
• Java有多种观察者模式的实现，包括了通用的java.util.Observable。
• 要注意java.util.Observable实现上所带来的一些问题。
• 如果有必要的话，可以实现自己的Observable，这并不难，不要害怕。
• Swing大量使用观察者模式，许多GUI框架也是如此。
• 此模式也被应用在许多地方，例如：JavaBeans、RMI。