【白话设计模式二】观察者模式(Observer)

1 场景问题

1.1 订阅报纸的过程

1.2 订阅报纸的问题

当一个对象的状态发生改变的时候，如何让依赖于它的所有对象得到通知，并进行相应的处理呢？

2 解决方案

2.1 观察者模式来解决

观察者模式把这多个订阅者称为观察者：Observer，多个观察者观察的对象被称为目标：Subject

2.2 模式结构和说明

1. 一个目标可以被多个观察者观察；

2. 目标提供对观察者注册和退订的维护；

3. 当目标的状态发生变化时，目标负责通知所有注册的、有效的观察者；

2.3 观察者模式示例代码

/**
* 目标对象，它知道观察它的观察者，并提供注册和删除观察者的接口
*/
public class Subject {
/**
* 用来保存注册的观察者对象
*/
private List<Observer> observers = new ArrayList<Observer>();
/**
* 注册观察者对象
* @param observer 观察者对象
*/
public void attach(Observer observer) {
observers.add(observer);
}
/**
* 删除观察者对象
* @param observer 观察者对象
*/
public void detach(Observer observer) {
observers.remove(observer);
}
/**
* 通知所有注册的观察者对象
*/
protected void notifyObservers() {
for(Observer observer : observers){
observer.update(this);
}
}
}

/**
* 具体的目标对象，负责把有关状态存入到相应的观察者对象，
* 并在自己状态发生改变时，通知各个观察者
*/
public class ConcreteSubject extends Subject {
/**
* 示意，目标对象的状态
*/
private String subjectState;
public String getSubjectState() {
return subjectState;
}
public void setSubjectState(String subjectState) {
this.subjectState = subjectState;
//状态发生了改变，通知各个观察者
this.notifyObservers();
}
}

/**
* 观察者接口，定义一个更新的接口给那些在目标发生改变的时候被通知的对象
*/
public interface Observer {
/**
* 更新的接口
* @param subject 传入目标对象，好获取相应的目标对象的状态
*/
public void update(Subject subject);
}

/**
* 具体观察者对象，实现更新的方法，使自身的状态和目标的状态保持一致
*/
public class ConcreteObserver implements Observer {
/**
* 示意，观者者的状态
*/
private String observerState;

public void update(Subject subject) {
// 具体的更新实现
//这里可能需要更新观察者的状态，使其与目标的状态保持一致
observerState = ((ConcreteSubject)subject).getSubjectState();
}
}

2.4 使用观察者模式实现示例

/**
* 目标对象，作为被观察者
*/
public class Subject {
/**
* 用来保存注册的观察者对象，也就是报纸的订阅者
*/
private List<Observer> readers = new ArrayList<Observer>();

/**
* 报纸的读者需要先向报社订阅，先要注册
* @param reader 报纸的读者
* @return 是否注册成功
*/
public void attach(Observer reader) {
readers.add(reader);
}
/**
* 报纸的读者可以取消订阅
* @param reader 报纸的读者
* @return 是否取消成功
*/
public void detach(Observer reader) {
readers.remove(reader);
}
/**
* 当每期报纸印刷出来后，就要迅速主动的被送到读者的手中，
* 相当于通知读者，让他们知道
*/
protected void notifyObservers() {
for(Observer reader : readers){
reader.update(this);
}
}
}

这个对象并没有定义出版报纸的功能，这是为了让这个对象更加通用，这个功能还是有的，放到具体报纸类里面去了

/**
* 报纸对象，具体的目标实现
*/
public class NewsPaper extends Subject{
/**
* 报纸的具体内容
*/
private String content;
/**
* 获取报纸的具体内容
* @return 报纸的具体内容
*/
public String getContent() {
return content;
}

/**
* 示意，设置报纸的具体内容，相当于要出版报纸了
* @param content 报纸的具体内容
*/
public void setContent(String content) {
this.content = content;
//内容有了，说明又出报纸了，那就通知所有的读者
notifyObservers();
}
}

/**
* 观察者，比如报纸的读者
*/
public interface Observer {
/**
* 被通知的方法
* @param subject 具体的目标对象，可以获取报纸的内容
*/
public void update(Subject subject);
}

/**
* 真正的读者，为了简单就描述一下姓名
*/
public class Reader implements Observer{
/**
* 读者的姓名
*/
private String name;

public void update(Subject subject) {
//这是采用拉的方式
System.out.println(name+"收到报纸了，阅读先。内容是==="+((NewsPaper)subject).getContent());
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Client {
public static void main(String[] args) {
//创建一个报纸，作为被观察者
NewsPaper subject = new NewsPaper();
//创建阅读者，也就是观察者
Reader reader1 = new Reader();
reader1.setName("张三");

Reader reader2 = new Reader();
reader2.setName("李四");

Reader reader3 = new Reader();
reader3.setName("王五");

//注册阅读者
subject.attach(reader1);
subject.attach(reader2);
subject.attach(reader3);

//要出报纸啦
subject.setContent("本期内容是观察者模式");
}
}

张三收到报纸了，阅读先。内容是===本期内容是观察者模式
李四收到报纸了，阅读先。内容是===本期内容是观察者模式
王五收到报纸了，阅读先。内容是===本期内容是观察者模式

3 模式讲解

3.1 认识观察者模式

如果是一个update的方法，那就需要在方法内部区分，到底这个更新的通知来自于哪一个目标，不同的目标有不同的后续操作

只有观察者依赖于目标，而目标是不会依赖于观察者的

它们之间联系的主动权掌握在目标手中

对目标而言，所有的观察者都是一样的，目标会一视同仁的对待

具体的目标实现对象要能维护观察者的注册信息

具体的目标实现对象需要维护引起通知的状态

具体的观察者实现对象需要能接收目标的通知

如果是一个观察者观察多个目标，那么在观察者的更新方法里面，需要去判断是来自哪一个目标的通知

因为通知会传递数据，不能够先通知后改数据

public void setContent(String content) {
//一激动，目标先发出通知了，然后才修改自己的数据，这会造成问题
notifyAllReader();
this.content = content;
}

第一个阶段是准备阶段

接下来就是实际的运行阶段了

当目标对象的状态变化后通知所有观察者的时候，顺序是不确定的

多个观察者之间的功能是平行的，相互不应该有先后的依赖关系

3.2 推模型和拉模型

推模型通常都是把需要传递的数据直接推送给观察者对象

/**
* 观察者，比如报纸的读者
*/
public interface Observer {
/**
* 被通知的方法，直接把报纸的内容推送过来
* @param content 报纸的内容
*/
public void update(String content);
}

public class Reader implements Observer{
/**
* 读者的姓名
*/
private String name;

public void update(String content) {
//这是采用推的方式
System.out.println(name+"收到报纸了，阅读先。内容是==="+content);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

/**
* 目标对象，作为被观察者，使用推模型
*/
public class Subject {
/**
* 用来保存注册的观察者对象，也就是报纸的订阅者
*/
private List<Observer> readers = new ArrayList<Observer>();
/**
* 报纸的读者需要先向报社订阅，先要注册
* @param reader 报纸的读者
* @return 是否注册成功
*/
public void attach(Observer reader) {
readers.add(reader);
}
/**
* 报纸的读者可以取消订阅
* @param reader 报纸的读者
* @return 是否取消成功
*/
public void detach(Observer reader) {
readers.remove(reader);
}
/**
* 当每期报纸印刷出来后，就要迅速的主动的被送到读者的手中，
* 相当于通知读者，让他们知道
* @param content 要主动推送的内容
*/
protected void notifyObservers(String content) {
for(Observer reader : readers){
reader.update(content);
}
}
}

public class NewsPaper extends Subject{
private String content;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
//内容有了，说明又出报纸了，那就通知所有的读者
notifyObservers(content);
}
}

3.3 Java中的观察者模式

在java.util包里面有一个类Observable，它实现了大部分我们需要的目标的功能

还有一个接口Observer，它里面定义了update的方法，就是观察者的接口

/**
* 报纸对象，具体的目标实现
*/
public class NewsPaper extends  java.util.Observable   {
/**
* 报纸的具体内容
*/
private String content;
/**
* 获取报纸的具体内容
* @return 报纸的具体内容
*/
public String getContent() {
return content;
}
/**
* 示意，设置报纸的具体内容，相当于要出版报纸了
* @param content 报纸的具体内容
*/
public void setContent(String content) {
this.content = content;
//内容有了，说明又出新报纸了，那就通知所有的读者
//注意在用Java中的Observer模式的时候，下面这句话不可少
this.setChanged();
//然后主动通知，这里用的是推的方式
this.notifyObservers(this.content);
//如果用拉的方式，这么调用
//this.notifyObservers();
}
}

/**
* 真正的读者，为了简单就描述一下姓名
*/
public class Reader implements   java.util.Observer   {
/**
* 读者的姓名
*/
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void update(Observable o, Object obj) {
//这是采用推的方式
System.out.println(name+"收到报纸了，阅读先。目标推过来的内容是==="+obj);

//这是获取拉的数据
System.out.println(name+"收到报纸了，阅读先。主动到目标对象去拉的内容是==="+((NewsPaper)o).getContent());
}
}

public class Client {
public static void main(String[] args) {
//创建一个报纸，作为被观察者
NewsPaper subject = new NewsPaper();
//创建阅读者，也就是观察者
Reader reader1 = new Reader();
reader1.setName("张三");

Reader reader2 = new Reader();
reader2.setName("李四");

Reader reader3 = new Reader();
reader3.setName("王五");

//注册阅读者
subject.addObserver(reader1);
subject.addObserver(reader2);
subject.addObserver(reader3);

//要出报纸啦
subject.setContent("本期内容是观察者模式");
}
}

王五收到报纸了，阅读先。目标推过来的内容是===本期内容是观察者模式
王五收到报纸了，阅读先。主动到目标对象去拉的内容是===本期内容是观察者模式
李四收到报纸了，阅读先。目标推过来的内容是===本期内容是观察者模式
李四收到报纸了，阅读先。主动到目标对象去拉的内容是===本期内容是观察者模式
张三收到报纸了，阅读先。目标推过来的内容是===本期内容是观察者模式
张三收到报纸了，阅读先。主动到目标对象去拉的内容是===本期内容是观察者模式

3.4 观察者模式的优缺点

3.5 思考观察者模式

观察者模式的本质：触发联动。

3.6 Swing中的观察者模式

Swing组件是被观察的目标，而每个实现监听器的类就是观察者，监听器的接口就是观察者的接口，在调用addXXXListener方法的时候就相当于注册观察者。

作为一个观察者，经常会注册观察多个不同的目标对象

这些监听器接口就相当于观察者接口，也就是说一个观察者要观察多个目标对象，只要不同的目标对象使用不同的观察者接口就好了

3.7 简单变形示例——区别对待观察者

解决的方式通常有两种，一种是目标可以通知，但是观察者不做任何操作；另外一种是在目标里面进行判断，干脆就不通知了。两种实现方式各有千秋，这里选择后面一种方式来示例，这种方式能够统一逻辑控制，并进行观察者的统一分派，有利于业务控制和今后的扩展。

/**
* 水质观察者接口定义
*/
public interface WatcherObserver {
/**
* 被通知的方法
* @param subject 传入被观察的目标对象
*/
public void update(WaterQualitySubject subject);
/**
* 设置观察人员的职务
* @param job 观察人员的职务
*/
public void setJob(String job);
/**
* 获取观察人员的职务
* @return 观察人员的职务
*/
public String getJob();
}

/**
* 具体的观察者实现
*/
public class Watcher implements WatcherObserver{
/**
* 职务
*/
private String job;
public String getJob() {
return this.job;
}
public void setJob(String job) {
this.job = job;
}

public void update(WaterQualitySubject subject) {
//这里采用的是拉的方式
System.out.println(job+"获取到通知，当前污染级别为："+subject.getPolluteLevel());
}
}

/**
* 定义水质监测的目标对象
*/
public abstract class WaterQualitySubject {
/**
* 用来保存注册的观察者对象
*/
protected List<WatcherObserver> observers = new ArrayList<WatcherObserver>();
/**
* 注册观察者对象
* @param observer 观察者对象
*/
public void attach(WatcherObserver observer) {
observers.add(observer);
}
/**
* 删除观察者对象
* @param observer 观察者对象
*/
public void detach(WatcherObserver observer) {
observers.remove(observer);
}
/**
* 通知相应的观察者对象
*/
public abstract void notifyWatchers();
/**
* 获取水质污染的级别
* @return 水质污染的级别
*/
public abstract int getPolluteLevel();
}

/**
* 具体的水质监测对象
*/
public class WaterQuality extends WaterQualitySubject{
/**
* 污染的级别，0表示正常，1表示轻度污染，2表示中度污染，3表示高度污染
*/
private int polluteLevel = 0;
/**
* 获取水质污染的级别
* @return 水质污染的级别
*/
public int getPolluteLevel() {
return polluteLevel;
}
/**
* 当监测水质情况后，设置水质污染的级别
* @param polluteLevel 水质污染的级别
*/
public void setPolluteLevel(int polluteLevel) {
this.polluteLevel = polluteLevel;
//通知相应的观察者
this.notifyWatchers();
}
/**
* 通知相应的观察者对象
*/
public void notifyWatchers() {
//循环所有注册的观察者
for(WatcherObserver watcher : observers){
//开始根据污染级别判断是否需要通知，由这里总控
if(this.polluteLevel >= 0){
//通知监测员做记录
if("监测人员".equals(watcher.getJob())){
watcher.update(this);
}
}
if(this.polluteLevel >= 1){
//通知预警人员
if("预警人员".equals(watcher.getJob())){
watcher.update(this);
}
}
if(this.polluteLevel >= 2){
//通知监测部门领导
if("监测部门领导".equals(watcher.getJob())){
watcher.update(this);
}
}
}
}
}

public class Client {
public static void main(String[] args) {
//创建水质主题对象
WaterQuality subject = new WaterQuality();
//创建几个观察者
WatcherObserver watcher1 = new Watcher();
watcher1.setJob("监测人员");
WatcherObserver watcher2 = new Watcher();
watcher2.setJob("预警人员");
WatcherObserver watcher3 = new Watcher();
watcher3.setJob("监测部门领导");

//注册观察者
subject.attach(watcher1);
subject.attach(watcher2);
subject.attach(watcher3);

//填写水质报告
System.out.println("当水质为正常的时候------------------〉");
subject.setPolluteLevel(0);
System.out.println("当水质为轻度污染的时候---------------〉");
subject.setPolluteLevel(1);
System.out.println("当水质为中度污染的时候---------------〉");
subject.setPolluteLevel(2);
}
}

当水质为正常的时候------------------〉
监测人员获取到通知，当前污染级别为：0
当水质为轻度污染的时候---------------〉
监测人员获取到通知，当前污染级别为：1
预警人员获取到通知，当前污染级别为：1
当水质为中度污染的时候---------------〉
监测人员获取到通知，当前污染级别为：2
预警人员获取到通知，当前污染级别为：2
监测部门领导获取到通知，当前污染级别为：2

具体要不要通知，什么时候通知都是目标对象的工作

3.8 相关模式

观察者模式的重心在触发联动，但是到底决定哪些观察者会被联动，这时就可以采用状态模式来实现了，也可以采用策略模式来进行选择需要联动的观察者