观察者模式
定义
定义对象间的一种一对多的依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆能收到通知并自动更新。
观察者模式又叫做发布-订阅模式(Publish/Subscribe);模型-视图模式(Model/View);源-监听器模式(Source/Listener);从属者模式(Dependents)。
观察者模式可以类比我们现在比较常见的微信订阅号。当我们订阅了某个订阅号之后,当该订阅有了新的文章都会在第一时间发送到我们的微信上。这里的订阅号就属于发布者,我们的就属于订阅者。一对多就是一个订阅号对应多个订阅用户。
组成角色
- Subject:主题/目标;一般为抽象类或者是接口。它就是我们的抽象的发布者,观察者观察的目标。它一般会包含一些抽象方法。比如:注册观察者;解除观察者,更新观察者等。
- ConcreteSubject:具体的主题/目标;它是Subject的实现类,是具体的的发布者。
- Observer:观察者;一般为抽象类或者是接口。它是抽象的接收者。它至少会包含一个抽象方法,那就是更新自己的方法。
- ConcreteObserver:具体观察者;该类为具体的观察者。它是具体的接收者。
它的结构图如下:
时序图如下:
具体示例
抽象的主题:
public abstract class Subject {
//记录当前的状态;将该状态分发给各个观察者
protected String mState;
//将观察者 注册、依附 到主题
public abstract void attach(Observer observer);
//将观察者从主题分离
public abstract void detach(Observer observer);
//主题发生改变通知所有的观察者更新
public abstract void notifyAllObserver(Subject subject);
//当前主题的状态,会将该状态分发给观察者
public abstract String getState();
//设置当前主题的状态
public abstract void setState(String state);
}
具体的主题:
public class ConcreteSubject extends Subject {
@Override
public String getState() {
return mState;
}
@Override
public void setState(String state) {
this.mState = state;
}
private List<Observer> mObservers = new ArrayList<>();
@Override
public void attach(Observer observer) {
if (observer != null) {
mObservers.add(observer);
}
}
@Override
public void detach(Observer observer) {
if (observer != null && mObservers.contains(observer)) {
mObservers.remove(observer);
}
}
@Override
public void notifyAllObserver(Subject subject) {
for (Observer o : mObservers) {
o.update(subject);
}
}
}
抽象的观察者:
public abstract class Observer {
public abstract void update(Subject subject);
}
具体观察者:
public class ConcreteObserver extends Observer {
@Override
public void update(Subject subject) {
System.out.println("当前的状态 = " + subject.getState());
}
}
所有的代码都写完。我们在主题里添加了两个额外的方法,由来设置和获取当前的主题状态。然后把设置的状态分发给各个观察者。我们在具体观察者里更新获取的状态。
我们测试一下:
Subject subject1 = new ConcreteSubject();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();
Observer observer3 = new ConcreteObserver();
subject1.attach(observer1);
subject1.attach(observer2);
subject1.attach(observer3);
subject1.setState("当前Subject1的状态");
subject1.notifyAllObserver(subject1);
System.out.println("----- Subject1 和 Subject2 的分割线 -----");
Subject subject2 = new ConcreteSubject();
subject2.attach(observer1);
subject2.attach(observer2);
subject2.attach(observer3);
subject2.setState("当前Subject2的状态");
subject2.notifyAllObserver(subject2);
}
这里使用的两个主题。两个主题设置不同的状态,然后把两个状态分发给观察者。输出内容如下:
当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
——– Subject1 和 Subject2 的分割线 ——–
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态
优点
- 观察者和观察目标之间是抽象耦合;符合开闭原则
- 使表示层和数据逻辑层分离。并定义了稳定的消息更新传递机制,抽象了更新接口,使得可以有各种各样不同的表示层作为具体观察者角色。
缺点
- 如果观察者过多,将会花费过多的性能和时间
- 观察者无法得知它的观察目标是如何发生变化的,而只是得到了通知
- 如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
- 如果顺序执行,某一观察者错误会导致系统卡壳,一般采用异步方式。
模式拓展
- 如果主题类型仅有一宗,那抽象的主题可以省略掉。直接使用具体的主题。
- 在Android中的广播跟这个模式类似。
使用场景
- 一对多;一个对象的改变将导致其他一个或多个对象也发生改变,而不知道具体有多少对象将发生改变,可以降低对象之间的耦合度。
- 一个对象必须通知其他对象,而并不知道这些对象是谁。
本文参考:http://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/builder.html
本文中的结构图和时序图来自:http://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/builder.html