前言
观察者模式是一个使用率非常高的模式，常用与GUI系统、订阅——发布系统。观察者模式一个重要作用就是解耦，将被观察者和观察者解耦，使得他们之间的依赖性更小，甚至做到毫无依赖。
观察者模式定义
定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得到通知并被自动更新。
观察者模式的UML类图
观察者模式的UML类图.png
- Subject: 抽象主题，也就是被观察的角色，抽象主题角色把所有观察者对象的引用保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
- ConcreteSubject: 具体主题，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发出通知，具体主题角色又叫具体被观察者（ConcreteObserver）角色。
- Observer: 抽象观察者，该角色是观察者的抽象类，它定义了一个更新接口，当收到主题的更改通知时更新自己。
- ConcreteObserver: 具体观察者，该角色实现抽象观察者角色所定义的更新接口，当收到主题变化通知时更新自己。
观察者模式的简单示例
以微信公众号为例，相信每个人都会关注一些自己感兴趣的公众号，比如我关注了InfoQ，这其实就是一种订阅——发布模式，当InfoQ 发布新文章时，所有关注它的人都能收到通知。
/**
* 抽象主题
*/
public abstract class Subject {
//保存观察者的集合
protected List observers = new ArrayList<>();
/**
* 注册观察者
*
* @param observer 观察者
*/
public void registerObservers(Observer observer) {
}
/**
* 删除观察者
*
* @param observer 观察者
*/
public void unRegisterObservers(Observer observer) {
}
/**
* 通知所有观察者
*/
@Override
public void notifyObservers(String content) {
for (Observer observer : observers) {
observer.update(content);
}
}
}
/**
* 具体主题
*/
public class InfoQ extends Subject {
@Override
public void registerObservers(Observer observer) {
observers.add(observer);
}
@Override
public void unRegisterObservers(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String content) {
for (Observer observer : observers) {
observer.update(content);
}
}
}
/**
* 抽象观察者
*/
public interface Observer {
/**
* 用于更新自身的方法
* @param content 更新的内容
*/
void update(String content);
}
/**
* 具体观察者
*/
public class Coder implements Observer {
private String mName;
public Coder(String name) {
mName = name;
}
@Override
public void update(String content) {
System.out.println("Hi: " + mName + " " + content);
}
}
/**
* 客户端调用
*/
public class Client {
public static void main(String[] args) {
InfoQ infoQ = new InfoQ();
Coder coder1 = new Coder("linda");
Coder coder2 = new Coder("mary");
Coder coder3 = new Coder("andy");
infoQ.registerObservers(coder1);
infoQ.registerObservers(coder2);
infoQ.registerObservers(coder3);
infoQ.notifyObservers("InfoQ发布新内容了，快来看看吧。");
}
}
输出日志如下：
Hi: linda InfoQ发布新内容了，快来看看吧。
Hi: mary InfoQ发布新内容了，快来看看吧。
Hi: andy InfoQ发布新内容了，快来看看吧。
以上示例中，Subject对应抽象主题的角色，InfoQ对应具体主题角色，Observer即抽象观察者角色，Code即具体观察者的角色，当InfoQ状态改变时，会遍历所有的Coder并通知Coder调用update()更新自身状态，完成了一对多的通知功能。在整个过程中InfoQ和Coder完全没有耦合，而是依赖Subject、Observer这些抽象类。保证了系统的灵活性，扩展性。
推模型和拉模型
- 推模型
主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。 - 拉模型
被观察者通过把自身的引用传递给观察者，需要观察者自行通过该引用来获取相关的信息。
如果想换成拉模型，只需要把主题对象自身通过update(Subject subject)方法传递给观察者，这样在观察者就可以根据需要获取数据了。如下：
//具体主题，即被观察者
public class InfoQ extends Subject {
@Override
public void registerObservers(Observer observer) {
observers.add(observer);
}
@Override
public void unRegisterObservers(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(this);
}
}
public String getContent() {
return "InfoQ发布新内容了，快来看看吧。";
}
}
/**
* 具体观察者
*/
public class Coder implements Observer {
private String mName;
public Coder(String name) {
mName = name;
}
@Override
public void update(Subject subject) {
String content = ((InfoQ) subject).getContent();
System.out.println("Hi: " + mName + " " + content);
}
}
两种模式的比较
- 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。
- 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。
Java中内置的观察者模式
在Java的java.util包中有一个类Observable(被观察者)和一个接口Observable（观察者）共同构成观察者模式。
Observable 源码如下：
public class Observable {
private boolean changed = false;
private Vector 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);
}
//通知观察者更新,会调用update方法，并传入自身和arg作为参数。
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
Object[] arrLocal;
synchronized (this) {
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();
}
//将标记changed设为true
protected synchronized void setChanged() {
changed = true;
}
//将标记changed设为false
protected synchronized void clearChanged() {
changed = false;
}
//检测是否被观察者状态发生变化
public synchronized boolean hasChanged() {
return changed;
}
//获取观察者的数量
public synchronized int countObservers() {
return obs.size();
}
}
Observer源码如下：
public interface Observer {
//用于更新观察者自身
void update(Observable o, Object arg);
}
可以看到 Java 内置的Observable已经帮我们实现了多个方法，方便了开发人员。
使用Java内置的观察者模式实现上面的小例子。
//具体主题，即被观察者
public class InfoQ extends Observable {
@Override
public void notifyObservers() {
setChanged();
super.notifyObservers();
}
public String getContent() {
return "InfoQ发布新内容了，快来看看吧。";
}
}
//具体观察者
public class Coder implements Observer {
private String mName;
public Coder(String name) {
mName = name;
}
@Override
public void update(Observable o, Object arg) {
String content = ((InfoQ)o).getContent();
System.out.println("Hi: " + mName + " " + content);
}
}
public class Client {
public static void main(String[] args) {
InfoQ infoQ = new InfoQ();
Coder coder1 = new Coder("linda");
Coder coder2 = new Coder("mary");
Coder coder3 = new Coder("andy");
infoQ.addObserver(coder1);
infoQ.addObserver(coder2);
infoQ.addObserver(coder3);
infoQ.notifyObservers();
}
}
日志如下：
Hi: andy InfoQ发布新内容了，快来看看吧。
Hi: mary InfoQ发布新内容了，快来看看吧。
Hi: linda InfoQ发布新内容了，快来看看吧。
总结
优点
- 观察者和被观察者之间是抽象耦合，应对业务变化。
- 增强系统灵活性、可扩展性
缺点
程序中包括一个被观察者、多个观察者，被观察者发出的通知默认顺序执行，一个观察者卡顿，会影响整体的执行效率，这种情况下，一般考虑采用异步的方式。