初识设计模式 chapter 02-观察者模式

初识设计模式 chapter 02-观察者模式

1 引言

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

2 正文

2.1 当前的境遇

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

2、当心的测量数据准备妥当时，measurementsChanged()方法就会被调用。

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

4、此系统必须可扩展，让其他开发人员建立定制的布告板，用户可以随心所欲地添加或删除任何布告板。

直接为每个布告板定义一个update()方法，并在measurementsChanged()方法中调用。这种方式会导致：

1、针对实现编程，而非针对接口编程。

2、对于每个新的布告板，我们都得修改代码。

3、我们无法在运行时动态地增加或者删除布告板。

4、我们尚未封装改变的部分。

2.2 观察者模式定义

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

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

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

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

2.3 设计类和接口

public class WeatherData implements Subject {
	private ArrayList observers;
	private float temperature;
	private float humidity;
	private float pressure;
	
	public WeatherData() {
		observers = new ArrayList();
	}
	
	public void registerObserver(Observer o) {
		observers.add(o);
	}
	
	public void removeObserver(Observer o) {
		int i = observers.indexOf(o);
		if (i >= 0) {
			observers.remove(i);
		}
	}
	
	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 float getTemperature() {
		return temperature;
	}
	
	public float getHumidity() {
		return humidity;
	}
	
	public float getPressure() {
		return pressure;
	}
}

首先为主题者设计一个接口用于实现观察者的注册、注销、通知，即Subject类，然后再为观察者设计两个接口，update接口用于更新数据，display用于显示数据。

用一个ArrayList来保存当前主题实例所订阅的观察者列表，以便数据变化时，主题者调用Notify（循环调用ArrayList中观察者的update方法更新数据）方法通知所有订阅的观察者。

其中的一个观察者类

public class ForecastDisplay implements Observer, DisplayElement {
	private float currentPressure = 29.92f;  
	private float lastPressure;
	private WeatherData weatherData;

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

	public void update(float temp, float humidity, float pressure) {
                lastPressure = currentPressure;
		currentPressure = pressure;

		display();
	}

	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");
		}
	}
}

2.4 使用java内置的观察者模式

Java内置Observer接口

1、先调用setChanged()方法，标记状态为已经改变的事实；

2、然后调用notifyObserver()或者notifyObserver(Object arg)方法通知观察者。

3、如果想把数据推送给观察者，就使用notifyPBserver(Object arg)方法，否则，观察者就必须从可观察者对象中“拉”

引入setChanged()方法可以有效的数据变化进行控制，是否需要每次数据变更都需要通知观察者。

可观察者类

public class WeatherData extends Observable {
	private float temperature;
	private float humidity;
	private float pressure;
	
	//构造器不用为了记住观察者而建立数据结构了arraylist,由observable自动管理
	public WeatherData() { }
	
	//这里没有调用notifyBoservers()传送数据对象，这表示我们采用的做法是“拉”
	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;
	
	//现在构造器需要一Observable当参数，并将实例登记为观察者
	public CurrentConditionsDisplay(Observable observable) {
		this.observable = observable;
		observable.addObserver(this);
	}
	
	//改变update()方法，增加Observable和数据对象作为参数
	//在update()中，先确定可观察者数据WeatherData类型，然后利用getter方法获取温度
	//和湿度测量值，最后调用display()
	public void update(Observable obs, Object arg) {
		if (obs instanceof WeatherData) {
			WeatherData weatherData = (WeatherData)obs;
			this.temperature = weatherData.getTemperature();
			this.humidity = weatherData.getHumidity();
			display();
		}
	}
	
	public void display() {
		System.out.println("Current conditions: " + temperature 
			+ "F degrees and " + humidity + "% humidity");
	}
}

2.5 java.util.Observable的黑暗面

1、Observable是一个类，因为没有接口，所以无法建立自己的实现，和java内置的Observable API搭配使用，也无法将java.util实现换乘另一套做法实现。

2、Observable将setChanged()方法定义为protocted，这意味着除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。这个设计违反了“多用组合，少用继承”。

3 本章小结

1、观察者模式中，会改变的是主题的状态，以及观察者的数量和类型。用这个模式，你可以改变依赖于主题状态的对象，却不必改变主题。这就叫提前规划。

2、主题与观察者都使用接口，观察者利用主题的接口向主题注册，而主题利用观察者接口通知观察者。这样可以让两者之间运作正常，又同时具有松耦合的有点。

3、观察模式利用“组合”将许多观察者组合进主题中。对象之间的这种关系不是通过继承产生的，而是在运行时利用组合的方式而产生的。