介绍
观察者模式是一个使用频率很高的模式。常用在 GUI系统，发布-订阅系统。 这个模式的一个重要作用就是 解耦，将观察者 和 被观察者 解耦，使得它们之间的依赖性更小，甚至做到毫无依赖。
定义
定义对象之间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。
使用场景
- 关联行为场景，注意“关联”关系可拆分，不是“组合”关系。
- 跨系统的信息交互场景，如消息队列、事件总线的处理机制。
类图
Observer Pattern UML
Observable：被观察的角色，被观察者把所有观察者对象的引用保存在一个集合里，每个 Observable 都可以有任意数量的观察者，Observable 提供一个接口，可以增加和删除观察者对象。
Observer：抽象观察者，该角色是观察者的抽象类，它定义了一个更新接口，使得在得到 被观察者 更新通知时更新自己。
ConcreteSubject：具体被观察者，该角色将有关状态存入具体观察者对象，在 ConcreteSubject 内部状态发生变化时，给所有注册过的观察者发出通知。
ConcreteObserver：具体的观察者，该角色实现抽象观察者角色所定义的更新接口，以便在 被观察者 的状态发生变化时更新自身的状态。
UML中 具体的观察者 和 具体的被观察者 是解耦的，双方都不需要知道对方是谁，甚至可以不知道对方的存在，这是通过更高层次的接口抽象达到的。
应用
自1.0版本开始，JDK 中已经内置了通用版本的 Observable： java.util.Observable 和 Observer：java.util.Observer 的抽象。 我们来看一下它们怎么实现的。
java.util.Observer ：
public interface Observer {
void update(Observable o, Object arg);
}
java.util.Observable ：
public class Observable {
private boolean changed = false; //表示被观察者状态的标识
private Vector<Observer> obs; //观察者集合
//构造函数
public Observable() {
obs = new Vector<>();
}
//添加观察者
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}
//删除观察者
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
//通知所有观察者更新
public void notifyObservers() {
notifyObservers(null);
}
//通知所有观察者更新
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
Object[] arrLocal;
synchronized (this) {
/* We don't want the Observer doing callbacks into
* arbitrary code while holding its own Monitor.
* The code where we extract each Observable from
* the Vector and store the state of the Observer
* needs synchronization, but notifying observers
* does not (should not). The worst result of any
* potential race-condition here is that:
* 1) a newly-added Observer will miss a
* notification in progress
* 2) a recently unregistered Observer will be
* wrongly notified when it doesn't care
*/
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
//清空观察者集合
public synchronized void deleteObservers() {
obs.removeAllElements();
}
//设置状态标识改变 true
protected synchronized void setChanged() {
changed = true;
}
//清除change标识 false
protected synchronized void clearChanged() {
changed = false;
}
// 返回标识的值
public synchronized boolean hasChanged() {
return changed;
}
//返回观察者的个数
public synchronized int countObservers() {
return obs.size();
}
}
实践
使用 jdk 中的抽象进行实践。
// 被观察者
public class Teacher extends Observable {
public void updateObserver(){
setChanged();
notifyObservers("下周一放学之前必须交作业");
}
}
// 观察者
public class Student implements Observer {
private String name;
public Student(String name){
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
System.out.println(this.name + " " + arg);
}
}
Teacher teacher = new Teacher();
Student s1 = new Student("Jack");
Student s2 = new Student("Tim");
Student s3 = new Student("LiLi");
teacher.addObserver(s1);
teacher.addObserver(s2);
teacher.addObserver(s3);
teacher.updateObserver();
运行结果：
LiLi 下周一放学之前必须交作业
Tim 下周一放学之前必须交作业
Jack 下周一放学之前必须交作业
网友评论