设计模式（Design Pattern）——观察者模式

观察者模式(Observer-Pattern)

tags:

[Subject Observer]

观察者模式也是一种运用非常广泛的模式了，Subject(主题)和Obesever(观察者)已经很好的阐述了什么是观察者模式，就好像报社，谁订阅了报纸，报只要在新闻有更新的时候就会定期给订阅报纸的人发放报纸，而如果有一天，出了某头条的应用，某人使用这个APP来查看每天自己感兴趣的新闻，从而去报社取消了订阅报纸，那么当报社出版新报纸的时候，就不再给这个人发送报纸了，那么这种关系，就称为观察者。

术语定义

观察者模式描述的是一种对象之间一对多的依赖关系，当一个对象的状态发生改变的时候，那么所有依赖者对象都会收到通知，然后做各自的具体实现

simple sample code

/**
* 主题接口，包括注册，移除和通知观察者
* @author Done
*/
public interface Subject {

void registerObserver(Observer observer);

void removeObserver(Observer observer);

void notifyObserver(Object data);
}

/**
* 观察者接口，再收到通知的时候，主题对象会去调用此接口，
* 而具体实现类（观察者）去做各自的实现
* @author Done
* @date 2017/12/6
* Created by Done on 2017/12/6.
*/

public interface Observer {
void onUpdate(Object data);
}

就这么简单的两个接口，但是却完成了一种很好的程序架构——松耦合

彼此不需要知道彼此具体的实现但仍然可以进行交互这也是本设计模式的设计原则核心——为了交互对象之间的松耦合而努力。

松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降到了最低

OK，结合现实生活开始我们的代码，首先咱们熟知的手撕对象：产品（ProductManager）和我们自己，两个工种作为我们的观察者对象，我们随时恭候BOSS的各项指令

public class ProductManager implements Observer {

@Override
public void onUpdate(Object data) {
System.out.println("Project Manager receive news:" + data.toString());
}
}

public class Coder implements Observer {

@Override
public void onUpdate(Object data) {
System.out.println("coder receive news:" + data.toString());
}
}

作为观察者，肯定必须先实现咱们之前提到的Observer接口，接收来自BOSS的指令，该干啥干啥，这里接口方法就简单定义成onUpdate了哈~

那么接下来是咱们的BOSS，发号施令者，代码如下：

public class Leader implements Subject {

private List<Observer> observers;

public Leader() {
observers = new ArrayList<>();
}

@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}

@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}

@Override
public void notifyObserver(Object data) {
for (Observer observer : observers) {
observer.onUpdate(data);
}
}
}

同样作为咱们的Subject主体，这里用List来存储咱们的观察者们，leader类实现Subject接口，分别是注册观察者

void registerObserver(Observer observer);

移除观察者

void removeObserver(Observer observer);

最后是咱们的通知观察者

void notifyObserver(Object data);

OK,能者多劳嘛，咱们Leader类身为leader更应该以身作则，比较能干嘛。。。

完成编码，进入咱们的run测试阶段

public static void main(String[] args) {
Leader leader = new Leader();
Coder coder = new Coder();
ProjectManager projectManager = new ProjectManager();
leader.registerObserver(coder);
leader.registerObserver(projectManager);
leader.notifyObserver("Today is a holiday!");
System.out.println("now leader remove project manager!");
leader.removeObserver(projectManager);
leader.notifyObserver("Overnight overtime today!");
}

输出:

coder receive news:Today is a holiday!
Project Manager receive news:Today is a holiday!
now leader remove project manager!
coder receive news:Work overtime today!

毋需多说，你懂的

话说JDK里面java.util包下面有这个模式，可见此模式的普遍适用性和实用性，没事大家可以参考一波，这里就不一一列举了，不过和以上所述有一点初入的地方就是JDK中的Observable是一个类，不是接口，你如果想要使用原生的观察者，就得继承这个类，那么就限制了你的观察者对象的复用潜力，稍微违背了我们那么一丢丢“增加复用潜力”，“多用组合，少用继承”的设计动机哈~

感兴趣的同学可以去参考一波JDK源码