设计模式_观察者模式_Observer
案例引入
有一个天气预报项目，需求如下：
- 气象站可以将每天测量到的温度、湿度、气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)
- 需要设计开放型API，便于其他第三方也能接入气象站获取数据
- 提供温度、气压、湿度的接口
- 测量数据更新时，要能实时的通知给第三方
原始方案实现
设计一个WeatherData类，类里面的方法如下：
- getTemperature0：获取温度
- getHumidity0：获取湿度
- getPressure0：获取气压
- dataChange0：可以定时（如每十分钟调用一次）调用该方法去气象站更新温度、湿度、气压数据，并主动推送给应用者
实现
【当前天气状况】
package com.test.observer;
/**
* 显示当前天气情况（可以理解成是气象站的网站）
* @author Administrator
*
*/
public class CurrentConditions {
/**
* 温度
*/
private float temperature;
/**
* 气压
*/
private float pressure;
/**
* 湿度
*/
private float humidity;
/**
* 更新 天气情况，是由WeatherData来调用将最新的数据推送过来
* @param temperature
* @param pressure
* @param humidity
*/
public void update(float temperature, float pressure, float humidity) {
this.temperature = temperature;
this.pressure = pressure;
this.humidity = humidity;
display();
}
/**
* 显示天气情况
*/
public void display() {
System.out.println("***Today mTemperature: " + temperature + "***");
System.out.println("***Today mPressure: " + pressure + "***");
System.out.println("***Today mHumidity: " + humidity + "***");
}
}
【气象台的天气数据】
package com.test.observer;
/**
* 类是核心
* 1. 包含最新的天气情况信息
* 2. 含有 CurrentConditions 对象
* 3. 当数据有更新时，就主动的调用CurrentConditions对象的update方法(含 display), 这样他们（接入方）就看到最新的信息
* @author Administrator
*
*/
public class WeatherData {
private float temperatrue;
private float pressure;
private float humidity;
private CurrentConditions currentConditions;
/**
* 加入新的第三方
* @param currentConditions
*/
public WeatherData(CurrentConditions currentConditions) {
this.currentConditions = currentConditions;
}
public float getTemperature() {
return temperatrue;
}
public float getPressure() {
return pressure;
}
public float getHumidity() {
return humidity;
}
public void dataChange() {
//调用 接入方的 update
currentConditions.update(getTemperature(), getPressure(), getHumidity());
}
/**
* 当数据有更新时，就调用 setData
* @param temperature
* @param pressure
* @param humidity
*/
public void setData(float temperature, float pressure, float humidity) {
this.temperatrue = temperature;
this.pressure = pressure;
this.humidity = humidity;
//调用dataChange， 将最新的信息 推送给 接入方 currentConditions
dataChange();
}
}
【主类】
package com.test.observer;
public class Client {
public static void main(String[] args) {
//创建接入方 currentConditions
CurrentConditions currentConditions = new CurrentConditions();
//创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData中
WeatherData weatherData = new WeatherData(currentConditions);
//更新天气情况
weatherData.setData(30, 150, 40);
//天气情况变化
System.out.println("============天气情况变化=============");
weatherData.setData(40, 160, 20);
}
}
【运行】
***Today mTemperature: 30.0***
***Today mPressure: 150.0***
***Today mHumidity: 40.0***
============天气情况变化=============
***Today mTemperature: 40.0***
***Today mPressure: 160.0***
***Today mHumidity: 20.0***
Process finished with exit code 0
问题分析
当添加其他第三方网站时，需要修改WeatherData类，不符合开闭原则，不利于维护
改进：推荐使用观察者模式
介绍
基础介绍
- 观察者模式的工作原理：观察者到观察对象中进行注册，当观察对象的状态发生改变时，就通知已经注册的观察者，观察者可以被从观察对象中移除
登场角色
Subject(观察对象)：Subject角色定义了注册、删除观察者的方法，还可以声明“获取现在的状态”的方法ConcreteSubject(具体的观察对象)：当自身状态发生变化后，它会通知所有已经注册的Observer角色Observer(观察者)：负责接收来自Subject角色状态变化的通知，声明了update方法来接收通知ConcreteObserver(具体的观察者)：当它的update方法被调用后，会去获取要观察的对象的最新状态
案例实现
案例一
类图
实现
【Subject：观察对象接口】
package com.test.observer.improve;
/**
* 接口, 让WeatherData 来实现
*/
public interface Subject {
/**
* 观察者注册
* @param o
*/
public void registerObserver(Observer o);
/**
* 移除观察者
* @param o
*/
public void removeObserver(Observer o);
/**
* 通知所有观察者
*/
public void notifyObservers();
}
【Observer：观察者接口】
package com.test.observer.improve;
/**
* 观察者接口
*/
public interface Observer {
/**
* 更新数据
*
* @param temperature
* @param pressure
* @param humidity
*/
public void update(float temperature, float pressure, float humidity);
}
【WeatherData：具体观察对象】
package com.test.observer.improve;
import java.util.ArrayList;
/**
* 类是核心
* 1. 包含最新的天气情况信息
* 2. 含有 观察者集合，使用ArrayList管理
* 3. 当数据有更新时，就主动的调用ArrayList, 通知所有的（接入方）就看到最新的信息
*
* @author Administrator
*/
public class WeatherData implements Subject {
private float temperature;
private float pressure;
private float humidity;
/**
* 观察者集合
*/
private ArrayList<Observer> observers;
/**
* 构造方法
*/
public WeatherData() {
// 创建新的集合
observers = new ArrayList<Observer>();
}
public float getTemperature() {
return temperature;
}
public float getPressure() {
return pressure;
}
public float getHumidity() {
return humidity;
}
public void dataChange() {
//调用 接入方的 update
notifyObservers();
}
//当数据有更新时，就调用 setData
public void setData(float temperature, float pressure, float humidity) {
this.temperature = temperature;
this.pressure = pressure;
this.humidity = humidity;
//调用dataChange， 将最新的信息 推送给 接入方 currentConditions
dataChange();
}
/**
* 注册一个观察者
* @param o
*/
@Override
public void registerObserver(Observer o) {
observers.add(o);
}
/**
* 移除一个观察者
* @param o
*/
@Override
public void removeObserver(Observer o) {
if (observers.contains(o)) {
observers.remove(o);
}
}
/**
* 遍历所有的观察者，并通知
*/
@Override
public void notifyObservers() {
for (int i = 0; i < observers.size(); i++) {
observers.get(i).update(this.temperature, this.pressure, this.humidity);
}
}
}
【CurrentConditions：具体观察者】
package com.test.observer.improve;
public class CurrentConditions implements Observer {
/**
* 温度
*/
private float temperature;
/**
* 气压
*/
private float pressure;
/**
* 湿度
*/
private float humidity;
/**
* 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
*
* @param temperature
* @param pressure
* @param humidity
*/
public void update(float temperature, float pressure, float humidity) {
this.temperature = temperature;
this.pressure = pressure;
this.humidity = humidity;
display();
}
/**
* 显示
*/
public void display() {
System.out.println("***Today mTemperature: " + temperature + "***");
System.out.println("***Today mPressure: " + pressure + "***");
System.out.println("***Today mHumidity: " + humidity + "***");
}
}
【BaiduSite：具体观察者】
package com.test.observer.improve;
/**
* 百度网站
*/
public class BaiduSite implements Observer {
private float temperature;
private float pressure;
private float humidity;
/**
* 更新天气情况，是由 WeatherData 来调用，我使用推送模式
*
* @param temperature
* @param pressure
* @param humidity
*/
public void update(float temperature, float pressure, float humidity) {
this.temperature = temperature;
this.pressure = pressure;
this.humidity = humidity;
display();
}
/**
* 显示
*/
public void display() {
System.out.println("===百度网站====");
System.out.println("***百度网站 气温 : " + temperature + "***");
System.out.println("***百度网站 气压: " + pressure + "***");
System.out.println("***百度网站 湿度: " + humidity + "***");
}
}
【主类】
package com.test.observer.improve;
public class Client {
public static void main(String[] args) {
//创建一个WeatherData
WeatherData weatherData = new WeatherData();
//创建观察者
CurrentConditions currentConditions = new CurrentConditions();
BaiduSite baiduSite = new BaiduSite();
//注册到weatherData
weatherData.registerObserver(currentConditions);
weatherData.registerObserver(baiduSite);
//测试
System.out.println("通知各个注册的观察者, 看看信息");
weatherData.setData(10f, 100f, 30.3f);
System.out.println();
System.out.println("----- 移除一个观察者 -----");
weatherData.removeObserver(currentConditions);
//测试
System.out.println();
System.out.println("通知各个注册的观察者, 看看信息");
weatherData.setData(10f, 100f, 30.3f);
}
}
【运行】
通知各个注册的观察者, 看看信息
***Today mTemperature: 10.0***
***Today mPressure: 100.0***
***Today mHumidity: 30.3***
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***
----- 移除一个观察者 -----
通知各个注册的观察者, 看看信息
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***
Process finished with exit code 0
分析
- 使用该模式，拓展方便，比如需要新增一个观察者，只需要实现一个具体的观察者类，然后在观察对象中注册即可
案例二
类图
实现
【观察者接口】
package com.test.observer.Sample;
public interface Observer {
public abstract void update(NumberGenerator generator);
}
12345
【被观察对象抽象类】
package com.test.observer.Sample;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 用来生成数值的抽象类
*/
public abstract class NumberGenerator {
/**
* 保存Observer们
*/
private ArrayList observers = new ArrayList();
/**
* 注册Observer
*
* @param observer
*/
public void addObserver(Observer observer) {
observers.add(observer);
}
/**
* 删除Observer
*
* @param observer
*/
public void deleteObserver(Observer observer) {
observers.remove(observer);
}
/**
* 向Observer发送通知
*/
public void notifyObservers() {
Iterator it = observers.iterator();
while (it.hasNext()) {
Observer o = (Observer) it.next();
o.update(this);
}
}
/**
* 获取数值
*
* @return
*/
public abstract int getNumber();
/**
* 生成数值
*/
public abstract void execute();
}
【具体的被观察对象】
package com.test.observer.Sample;
import java.util.Random;
/**
* 具体的被观察对象
*/
public class RandomNumberGenerator extends NumberGenerator {
/**
* 随机数生成器
*/
private Random random = new Random();
/**
* 当前数值
*/
private int number;
/**
* 获取当前数值
* @return
*/
public int getNumber() {
return number;
}
public void execute() {
for (int i = 0; i < 20; i++) {
// 生成随机数
number = random.nextInt(50);
// 通知观察者
notifyObservers();
}
}
}
【数值显示观察者】
package com.test.observer.Sample;
/**
* 使用数字形式显示观察到的数值
*/
public class DigitObserver implements Observer {
public void update(NumberGenerator generator) {
System.out.println("DigitObserver:" + generator.getNumber());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}
【图像显示观察者】
package com.test.observer.Sample;
/**
* 使用图像显示观察到的数值
*/
public class GraphObserver implements Observer {
public void update(NumberGenerator generator) {
System.out.print("GraphObserver:");
int count = generator.getNumber();
for (int i = 0; i < count; i++) {
System.out.print("*");
}
System.out.println("");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}
【主类】
package com.test.observer.Sample;
public class Main {
public static void main(String[] args) {
NumberGenerator generator = new RandomNumberGenerator();
Observer observer1 = new DigitObserver();
Observer observer2 = new GraphObserver();
generator.addObserver(observer1);
generator.addObserver(observer2);
generator.execute();
}
}
【运行】
DigitObserver:2
GraphObserver:**
DigitObserver:7
GraphObserver:*******
DigitObserver:6
GraphObserver:******
DigitObserver:26
GraphObserver:**************************
DigitObserver:16
GraphObserver:****************
DigitObserver:6
GraphObserver:******
DigitObserver:28
GraphObserver:****************************
DigitObserver:10
GraphObserver:**********
DigitObserver:6
GraphObserver:******
DigitObserver:10
GraphObserver:**********
DigitObserver:20
GraphObserver:********************
DigitObserver:14
GraphObserver:**************
DigitObserver:21
GraphObserver:*********************
DigitObserver:38
GraphObserver:**************************************
DigitObserver:31
GraphObserver:*******************************
DigitObserver:34
GraphObserver:**********************************
DigitObserver:19
GraphObserver:*******************
DigitObserver:30
GraphObserver:******************************
DigitObserver:0
GraphObserver:
DigitObserver:1
GraphObserver:*
Process finished with exit code 0
观察者模式在JDK源码的应用
Observable直接就是类，没有实现Subject接口，直接在类中实现管理Observer的核心方法，当然，可以写更多的子类来集成Observable以便实现更多的操作
总结
- 可替换性强：被观察对象中的观察者集合的观察者类型是Observer角色，可以接收各种各样的具体Observer角色，而且可以统一调用他们的update方法；Observer的update方法接收的数据类型也是Subject，在update方法里面也可以统一调用方法来获取具体被观察对象的属性
- update方法所需要的参数非常灵活，可以自己按照需求来定义
- 观察者模式并非主动去观察，而是被观测对象主动去通知，称为发布——订阅模式可能更加贴切