-
定义：观察者模式定义了一系列一对多的关系，当一个对象改变状态，其他依赖者都会收到通知。
从类图上看其实就是一个Subject(主题)依赖多个Observer（观察者），一个Observer依赖一个Subject。一对多的关系。Subject定义了观察者注册和注销的方。以及主题改变时通知在线观察者的方法。Observer定义了当主题改变式，被通知时要调用的update方法。关键在这个依赖。当Observer被实例化的时候，会告诉调用Subject的registerObserver()注册到Subject。当Subject更新的时候会最终调用Observer的update方法通知到观察者。
松耦合设计原则：连个对象之间要交互，暴露的东西越少越好。只需要知道对方能干嘛，而不需要知道具体怎么实现的。本例中。Observer不需要知道Subject怎么通知我的，只需要知道，通知我update方法被调用了即可。反过来。Subject不需要知道Observer具体是谁，做了什么。只需要知道它是个Observer即可。
案例：气象站的设计
需求： 目前已经有WeatherData类。里面有获取温度、湿度、气压的方法。当新的数据备妥时measurementsChanged方法会被调用。现在需要增加三个使用天气数据的的布告板，分别是“目前状况”布告、“天气预报”布告、“气象统计”布告。并且要求这些布告是可以拓展的，也就是可以删除也可以增加其他布告板。
错误的代码设计：面向过程（直接怼代码）
既然知道了当数据更新的时候measurementsChanged方法会被调用，那直接在上面写代码就可以实现需求了。于是写出了类似下面的代码。简称“直接怼”。这就很不友好了。这样的后果就是日后如果气象站有所变更，我需要直接修改代码。在公共的代码区域直接修改代码会造成意想不到的结果。比如所有被通知的布告板，出现了不该出现的数据。
public class WeatherData {
public String getTemperature(){
return "温度";
}
public String getHumidity(){
return "湿度";
}
public String getPressure(){
return "气压";
}
/**
* 新的测量数据备好后会被调用
*/
public void measurementssChanged(){
String temperature = getTemperature();
String humidity = getHumidity();
String pressure = getPressure();
//目前
currentConditionsDisplay.update(temperature,humidity,pressure);
//统计
statisticsDisplay.update(temperature, humidity, pressure);
//预报
forecastDisplay.update(temperature, humidity, pressure);
}
}
使用观察者模式
思考：该需求很适合使用观察者模式，气象站需要给布告板数据，而布告板展示数据。这不就是观察者模式的经典吗。
1、定义被观察者接口：主题
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:10.
*
* 主题接口：对象使用此接口注册为观察者。或者把自己是删除。
*/
public interface Subject {
/**
* 注册为观察者
*/
void registerObserver(Observer observer);
/**
* 从观察者列表里删除（注销）
*/
void removeObserver(Observer observer);
/**
* 通知当前所有观察者，主题状态改变
*/
void notifyObserver();
}
2、定义观察者接口
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:14.
*
* 观察者接口：所有潜在的观察者必须实现观察者接口，该demo中只有update一个方法，当Subject状态改变时，它被调用
*/
public interface Observer {
void udpate(float temp, float humidity,float pressure);
}
3、定义业务功能接口
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:31.
*/
public interface DisplayElement {
/**
* 布告板展示时调用此方法
*/
void display();
}
4、实现具体主题
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/14 16:48.
*/
public class WeatherData implements Subject{
//依赖观察者：subject包含多个Observer
private ArrayList<Observer> observers;
//温度
private float temperature;
//湿度
private float humidity;
//气压
private float pressure;
public WeatherData() {
this.observers = new ArrayList<Observer>();
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
if (observers.indexOf(observer) >= 0) {
observers.remove(observer);
}
}
@Override
public void notifyObserver() {
for (Observer observer : observers) {
observer.udpate(temperature,humidity,pressure);
}
}
/**
* 新的测量数据备好后会被调用
*/
public void measurementsChanged(){
notifyObserver();
}
public void setMeasurements(float temperature,float humidity, float pressure){
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
}
5、实现具体观察者
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:32.
*/
public class CurrentConditionDisplay implements Observer, DisplayElement {
//依赖具体被观察者（主题）
private Subject weatherData;
private float temperature;
private float humidity;
private float pressure;
public CurrentConditionDisplay(Subject weatherData) {
this.weatherData = weatherData;
//注册
weatherData.registerObserver(this);
}
@Override
public void display() {
System.out.println("CurrentCondition:");
System.out.println("temperature = " + temperature);
System.out.println("humidity = " + humidity);
System.out.println("pressure = " + pressure);
}
@Override
public void udpate(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
display();
}
}
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:32.
*/
public class ForecastDisplay implements Observer, DisplayElement {
private Subject weatherData;
private float temperature;
private float humidity;
private float pressure;
public ForecastDisplay(Subject weatherData) {
this.weatherData = weatherData;
//注册
weatherData.registerObserver(this);
}
@Override
public void display() {
System.out.println("Forecast:");
System.out.println("temperature = " + temperature);
System.out.println("humidity = " + humidity);
System.out.println("pressure = " + pressure);
}
@Override
public void udpate(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
display();
}
}
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:32.
*/
public class StatisticDisplay implements Observer, DisplayElement {
private Subject weatherData;
private float temperature;
private float humidity;
private float pressure;
public StatisticDisplay(Subject weatherData) {
this.weatherData = weatherData;
//注册
weatherData.registerObserver(this);
}
@Override
public void display() {
System.out.println("Statistic:");
System.out.println("temperature = " + temperature);
System.out.println("humidity = " + humidity);
System.out.println("pressure = " + pressure);
}
@Override
public void udpate(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
display();
}
}
6、测试
public class Test {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherData);
StatisticDisplay statisticDisplay = new StatisticDisplay(weatherData);
ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
weatherData.setMeasurements(12,12,12);
weatherData.setMeasurements(13,13,13);
}
}
总结
思考：
观察者模式的核心思想小编理解是松耦合的实现思想。相互依赖，仅仅暴露需要传输的部分，其他隐藏在各自的区域中。相互只知道相互需要知道的东西，一点不多一点不少。利用组合的思想。面向接口编程。方便拓展并且实现了解耦，主题和观察者解耦，业务和观察者解耦。代码是相互独立的，使用是相互依赖的。
缺点：
本例后，当我们尝试去拓展一个新的Subject的时候，我们会发现我们写了重复的代码。注册删除和通知Observer这些方法在每一个实现类当中都需要去实现。关于这个，使用jdk8的小伙伴们说很容易解决的啦。jdk8支持接口方法的默认实现嘛，子类可以不实现这些方法。 比如这样。
public interface Subject {
ArrayList<Observer> observers = new ArrayList<Observer>();
/**
* 注册为观察者
*/
default void registerObserver(Observer observer){
observers.add(observer);
}
/**
* 从观察者列表里删除（注销）
*/
default void removeObserver(Observer observer){
if (observers.indexOf(observer) >= 0) {
observers.remove(observer);
}
}
/**
* 通知当前所有观察者，主题状态改变
*/
void notifyObserver();
}
public class WeatherData implements Subject {
private float temperature;
private float humidity;
private float pressure;
@Override
public void notifyObserver() {
for (Observer observer : observers) {
observer.udpate(temperature, humidity, pressure);
}
}
/**
* 新的测量数据备好后会被调用
*/
public void measurementsChanged() {
notifyObserver();
}
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
}
JDK内置观察者模式
其实在java.util下已经内置好咯额观察者模式供我们使用。只不过不同于上面的案例。我们可以看一下具体区别在哪。
JDK定义Observable类为被观察者，对，没看错，这个是类，比起之前我们自己定义的Subject，多了一个状态changed属性，调用setChanged方法设置为true，调用notifyObservers方法的时候设置为false，changed的设计可以让我们更有效的控制变化的通知频率，更加灵活。观察者是接口Observer。update方法接受一个具体被观察者以及Object类型的参数。接受的参数就包含了依赖的被观察者，第二个参数方便我们根据业务传入其他的参数。
使用JDK内置观察者模式改造气象站
import java.util.Observable;
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float 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() {
setChanged();
notifyObservers();
}
public float getPressure() {
return pressure;
}
public float getTemperature() {
return temperature;
}
public float getHumidity() {
return humidity;
}
}
import com.example.observer.demo5.DisplayElement;
import com.example.observer.demo5.subject.WeatherData;
import java.util.Observable;
import java.util.Observer;
/**
* Project <demo-project>
* Created by jorgezhong on 2018/9/18 9:32.
*/
public class CurrentConditionDisplay implements Observer, DisplayElement {
private Observable observable;
private float temperature;
private float humidity;
private float pressure;
public CurrentConditionDisplay(Observable observable) {
this.observable = observable;
//注册
observable.addObserver(this);
}
@Override
public void display() {
System.out.println("CurrentCondition:");
System.out.println("temperature = " + temperature);
System.out.println("humidity = " + humidity);
System.out.println("pressure = " + pressure);
}
@Override
public void update(Observable observable, Object arg) {
if (observable instanceof WeatherData) {
WeatherData weatherData = (WeatherData) observable;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
this.pressure = weatherData.getPressure();
display();
}
}
}
image.png
案例总结：
JDK内置的观察者模式考虑的会多一点，比如changed的设置。比如Observer接收Observable和参数Object会更加适合实际应用。但是由于被观察者使用的是继承，我们的设计原则是多用组合少用继承。既然可以用接口改造那就用接口改造好了。jdk8也支持接口方法的默认实现。还有一点区别，用jdk的实现是无法保证通知顺序的，因此不要选择依赖通知的顺序。
设计原则：
- 松耦合:所有的设计都尽量松耦合。设计为此而努力
- 开闭原则：对拓展开放，对修改关闭。观察者模式中我们可以通过拓展被观察者而实现拓展，不对旧的代码做出修改符合开闭原则。
-重点设计：我们发现使用了设计模式会大量使用接口抽象方法。抽象多了，层次就会增多。同样的，遵循开闭原则的代码一般都会引入新的抽象层次，增加代码的复杂性，太复杂的代码往往都不好理解，失去了其意义。因此对重点进行设计，避免过度设计。
