观察者模式
观察者模式
气象站项目
好消息，你们公司和气象站签订了一笔500W的项目，老板说只要顺利搞定了这个项目，奖励项目组成员到三亚晒太阳（6月的天…)。
需求很简单，气象站会搜集湿度、温度、气压等气象数据，然后放到一个叫WeatherData对象中，现在需要我们来监控WeatherData对象，当里面的气象数据发生变更后，要将变更显示到布告板上，而布告板目前需要提供的有"目前状态"布告板，"气象统计"布告板，"天气预报"布告板；同时系统要提供布告板的可扩展性，即可以非常容易的添加新的布告板，或删除已有的布告板。
先看看WeatherData类长什么样子，这是由气象站提供的。
/**
* 天气数据
* 由气象站提供的类
*/
public class WeatherData {
private float temperature; //温度
private float humidity; //湿度
private float pressure; //气压
/**
* 当新的气象数据准备妥当时，会调用这个方法
* 此时就需要我们来更新布告板信息。
*/
public void measurementsChanged(){
//这儿就是我们需要去实现的代码。
}
public float getTemperature() {
return temperature;
}
public void setTemperature(float temperature) {
this.temperature = temperature;
}
public float getHumidity() {
return humidity;
}
public void setHumidity(float humidity) {
this.humidity = humidity;
}
public float getPressure() {
return pressure;
}
public void setPressure(float pressure) {
this.pressure = pressure;
}
}
气象数据发生变更后，会调用measurementsChanged()这个方法（我们不用管是怎么调用的），我们需要实现这个方法，来通知布告板更新。
需求清楚后，我们就开始来设计吧。既然是measurementsChanged()方法要变更布告板信息，那我们在里面直接调用布告板的相关方法不就行了吗。
V1版本
基于这样的思路，我们来实现V1版本。布告板有多种类型，通过OO思想，我们非常容易可以抽象出来一个布告板的抽象出来。
/**
* 布告板抽象
*/
public interface DisplayV1 {
/**
* 更新布告板
* @param data 气象数据
*/
void update(WeatherDTOV1 data);
}
数据对象WeatherDTOV1
/**
* 气象数据封装
*/
public class WeatherDTOV1 {
private float temperature; //温度
private float humidity; //湿度
private float pressure; //气压
public WeatherDTOV1(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
}
public float getTemperature() {
return temperature;
}
public void setTemperature(float temperature) {
this.temperature = temperature;
}
public float getHumidity() {
return humidity;
}
public void setHumidity(float humidity) {
this.humidity = humidity;
}
public float getPressure() {
return pressure;
}
public void setPressure(float pressure) {
this.pressure = pressure;
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("WeatherDTOV1{");
sb.append("temperature=").append(temperature);
sb.append(", humidity=").append(humidity);
sb.append(", pressure=").append(pressure);
sb.append('}');
return sb.toString();
}
}
实现需求需要的三个布告板
/**
* 目前状况布告板
*/
public class CurrentConditionsDisplayV1 implements DisplayV1 {
@Override
public void update(WeatherDTOV1 data) {
System.out.println("目标状况布告板更新，新数据:"+data.toString());
}
}
/**
* 气象统计布告板
*/
public class StatisticsDisplayV1 implements DisplayV1 {
@Override
public void update(WeatherDTOV1 data) {
System.out.println("气象统计布告板更新，新数据:"+data.toString());
}
}
/**
* 天气预报布告板
*/
public class ForecastDisplayV1 implements DisplayV1 {
@Override
public void update(WeatherDTOV1 data) {
System.out.println("天气预报布告板更新，新数据:"+data.toString());
}
}
最后，我们在WeatherDataV1的measurementsChanged()方法中，依次调用布告板更新信息。
/**
* 当新的气象数据准备妥当时，会调用这个方法
* 此时就需要我们来更新布告板信息。
*/
public void measurementsChanged(){
//这儿就是我们需要去实现的代码。
WeatherDTOV1 weatherDTOV1 =
new WeatherDTOV1(getTemperature(), getHumidity(), getPressure());
CurrentConditionsDisplayV1 currentConditionsDisplay = new CurrentConditionsDisplayV1();
currentConditionsDisplay.update(weatherDTOV1);
StatisticsDisplayV1 statisticsDisplay = new StatisticsDisplayV1();
statisticsDisplay.update(weatherDTOV1);
ForecastDisplayV1 forecastDisplay = new ForecastDisplayV1();
forecastDisplay.update(weatherDTOV1);
}
实现了我们的需求，可是没福利。
分析V1版本设计会存在什么问题？
- WeatherDataV1和具体布告板代码强耦合在一起，我们应该针对接口编程，而不是针对实现。
- 如果要新增或者移除布告板，那么就要修改WeatherDataV1的代码，不符合开闭原则。
这个场景其实是一个典型使用观察者模式的一个场景。
我们举个报纸的订阅例子，来理解下什么是观察者模式（也叫发布订阅模式）。
彭城晚报是一家报社出版的报纸，老周已经订阅了彭城晚报，那么每当有新的晚报出版后，都会送到老周手上。
当老周不再看晚报后，他可以取消订阅，这样报社就不会再给他送报纸了。只要这家报社还在，就一直会有人不断的订阅或者取消订阅报纸。
该场景对应到观察者模式中，报社称之为"主题"，老周就是"观察者"，观察者（老周）可以订阅（注册）到主题上，这样当主题状态发生变更时（出版新报纸），就会通知到已经订阅的观察者（老周）。观察者（老周）也可以取消订阅。
这样我们就可以抽象出主题对象，里面会有注册、取消注册观察者的方法，以及通知观察者的方法；而观察者有更新自己状态方法。
V2版本
好了，介绍完观察者是什么之后，用观察者来实现我们的天气项目。
观察者抽象（V1版本一致）
/**
* 布告板抽象（就是观察者抽象，有一个更新自己状态的方法)
*/
public interface DisplayV2 {
/**
* 更新布告板
* @param data 气象数据
*/
void update(WeatherDTOV1 data);
}
观察者的实现同V1版本一样，就不用重复贴代码了。
主题抽象，有注册观察者、移除观察者、通知观察者的方法。
/**
* 主题抽象
*/
public interface Subject {
/**
* 注册观察者(布告板)
* @param display
*/
void registerDisplay(DisplayV2 display);
/**
* 移除观察者(布告板)
* @param display
*/
void removeDisplay(DisplayV2 display);
/**
* 通知观察者(布告板)
*/
void notifyDisplay();
}
主题实现，让WeatherDataV2实现主题接口。
/**
* 天气数据
* 由气象站提供的类
*/
public class WeatherDataV2 implements Subject{
private float temperature; //温度
private float humidity; //湿度
private float pressure; //气压
private List<DisplayV2> displays = new ArrayList<>(5); //布告板列表（观察者列表）
/**
* 当新的气象数据准备妥当时，会调用这个方法
* 此时就需要我们来更新布告板信息。
*/
public void measurementsChanged(){
//这儿就是我们需要去实现的代码。
notifyDisplay();
}
@Override
public void registerDisplay(DisplayV2 display) {
displays.add(display);
}
@Override
public void removeDisplay(DisplayV2 display) {
displays.remove(display);
}
@Override
public void notifyDisplay() {
WeatherDTOV2 weatherDTO =
new WeatherDTOV2(getTemperature(), getHumidity(), getPressure());
displays.forEach(display -> display.update(weatherDTO));
}
//getter setter 略
}
来吧，测试一波看看
/**
* V2版测试
*/
public class WeatherMainV2 {
public static void main(String[] args) {
WeatherDataV2 weatherData = new WeatherDataV2();
//注册观察者
weatherData.registerDisplay(new CurrentConditionsDisplayV2());
weatherData.registerDisplay(new ForecastDisplayV2());
weatherData.registerDisplay(new StatisticsDisplayV2());
//气象数据发生变更
weatherData.setTemperature(34.5f);
weatherData.setHumidity(125.7f);
weatherData.setPressure(32.4f);
//调用我们实现的方法。通知观察者
weatherData.measurementsChanged();
}
}
nice，非常完美。
V2版本的UML图
使用观察者模式能不能解决V1版本的问题呢，首先Subject 和 WeatherDataV2对象只依赖 观察者抽象（DisplayV2），不依赖具体的观察者实现。实际上这就是依赖倒置原则的体现。
其次，现在我们要新增观察者时，只需要新提供一个观察者的实现（扩展类），然后注册到WeatherDataV2中即可，同理移除观察者，只需要取消注册即可，符合开闭原则。
nice，三亚半月游，妥妥的。
对于气象站这个项目，我们没有测试移除观察者，你可以自行实现体验下看看（注意的移除实现可能存在问题哦，你可以自己发现并解决）。
定义
观察者模式的定义，观察者模式定义了对象之前的一对多的关系，这样，当一的对象状态发生变化时，多的对象会接受到通知并更新。
我们用代码实现下
抽象观察者
/**
* 抽象观察者
*/
public interface Observer {
/**
* 更新方法
* @param event 事件信息
*/
void update(Event event);
}
它通常会依赖一个数据对象，而且我们也常常叫它事件对象。
/**
* 事件（封装数据）
*/
public class Event {
}
具体观察者实现
/**
* 具体观察者A
*/
public class ConcreteObserverA implements Observer{
@Override
public void update(Event event) {
System.out.println("具体观察者A接收到事件，更新......");
}
}
/**
* 具体观察者B
*/
public class ConcreteObserverB implements Observer{
@Override
public void update(Event event) {
System.out.println("具体观察者B接收到事件，更新......");
}
}
抽象主题，依赖抽象观察者，提供注册、移除、通知接口。
/**
* 抽象主题
*/
public interface Subject {
/**
* 注册观察者
* @param observer
*/
void registerObserver(Observer observer);
/**
* 移除观察者
* @param observer
*/
void removeObserver(Observer observer);
/**
* 通知观察者
*/
void notifyObservers();
}
具体主题
/**
* 具体主题
*/
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
Event event = new Event();
observers.forEach(observer -> observer.update(event));
}
}
测试一波
/**
* 观察者测试
*/
public class ObserverMain {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
subject.registerObserver(new ConcreteObserverA());
subject.registerObserver(new ConcreteObserverB());
subject.notifyObservers();
}
}
观察者模式的UML图
JDK内置实现
因为观察者模式非常的常用，JDK已经内置了观察者模式。
其抽象主题是java.util.Observable，它是一个抽象类，实现了添加、删除、通知 观察者的实现。
抽象观察者是java.util.Observer，它是一个接口，定义了更新方法。
你可以改造我们的V2版本，使用JDK内置的观察者模式来实现。
但通常我们很少使用内置的观察者模式，这是因为它的主题对象是一个抽象类，要使用它的功能时，必须继承它，
因为java语法不支持多继承，当类已经继承其他超类时就无能为力了。另外Observable将一些关键的方法设置为protected，这意味着只能通过继承来复用，而不能通过组合Observable，来使用其中的一些关键方法，违反了多用组合，少用继承的原则。
扩展示例
为了加深理解，我们再来实现一个微信公众号的场景。（https://codepumpkin.com/observer-design-pattern/）
有一个叫"设计模式"的微信公众号，假如有张三，李四，王五三个同学关注，那么每当公众号推送新的文章时，都会及时通知这3位观察者。
某天，张三取消关注，那么之后推送的新文章，张三不会再收到。
同样的，定义抽象观察者（粉丝）
/**
* 抽象观察者
*/
public interface Observer {
/**
* 更新方法
* @param event 事件信息
*/
void update(Event event);
}
依赖的事件对象
/**
* 事件（封装数据）
*/
public class Event {
private String officialAccountName;
private String articleName;
public Event(String officialAccountName, String articleName) {
this.officialAccountName = officialAccountName;
this.articleName = articleName;
}
//setter getter 忽略
}
具体观察者实现
/**
* 粉丝
*/
public class Follower implements Observer {
private String name;
public Follower(String name) {
this.name = name;
}
@Override
public void update(Event event) {
System.out.println(getName() + ",接受到公众号"+ event.getOfficialAccountName() +"推送的新文章:" + event.getArticleName());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
抽象主题
/**
* 抽象主题
*/
public interface Subject {
/**
* 注册观察者
* @param observer
*/
void registerObserver(Observer observer);
/**
* 移除观察者
* @param observer
*/
void removeObserver(Observer observer);
/**
* 通知观察者
*/
void notifyObservers();
}
具体主题（公众号）
/**
* 公众号（具体主题）
*/
public class OfficialAccount implements Subject {
private String name;
private List<Observer> observers;
private String lastArticle;
public OfficialAccount(String name) {
this.name = name;
observers = new ArrayList<>();
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
System.out.println(name + "公众号新增粉丝...");
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
System.out.println(name + "公众号掉粉...");
}
@Override
public void notifyObservers() {
Event event = new Event(name, lastArticle);
observers.forEach(observer -> observer.update(event));
}
public void pushArticle(String articleName){
this.lastArticle = articleName;
notifyObservers();
}
}
测试一波
/**
* 公众号测试
*/
public class OfficialAccountMain {
public static void main(String[] args) {
OfficialAccount account = new OfficialAccount("设计模式");
Observer zhangsan = new Follower("张三");
account.registerObserver(zhangsan);
account.registerObserver(new Follower("李四"));
account.registerObserver(new Follower("王五"));
System.out.println("推送新文章。。。");
account.pushArticle("观察者模式");
account.removeObserver(zhangsan);
System.out.println("推送新文章。。。");
account.pushArticle("策略模式");
}
}
测试结果：
设计模式公众号新增粉丝...
设计模式公众号新增粉丝...
设计模式公众号新增粉丝...
推送新文章。。。
张三,接受到公众号设计模式推送的新文章:观察者模式
李四,接受到公众号设计模式推送的新文章:观察者模式
王五,接受到公众号设计模式推送的新文章:观察者模式
设计模式公众号掉粉...
推送新文章。。。
李四,接受到公众号设计模式推送的新文章:策略模式
王五,接受到公众号设计模式推送的新文章:策略模式
源码
https://gitee.com/cq-laozhou/design-pattern