让你的对象知悉现况
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. 认识观察者模式
我们看看报纸和杂志的订阅是怎么回事:
- 报社的业务就是出版报纸。
- 向某家报社订阅报纸,只要他们有新报纸出版,就会给你送来。只要你是他们的订户,你就会一直收到新报纸。
- 当你不想再看报纸的时候,取消订阅,他们就不会再送新报纸来。
- 只要报社还在运营,就会一直有人(或单位)向他们订阅报纸或取消订阅报纸。
出版者+订阅者=观察者模式
如果你了解报纸的订阅是怎么回事,其实就知道观察者模式是怎么回事,只是名称不太一样:出版者改称为“主题”(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。
转载请注明原文链接:ZJ-Wave
共有 0 条评论