观察者模式

1.观察者模式模式简介

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

观察者模式结构图

2.观察者模式简单实现

观察者模式这种发布-订阅的形式我们可以拿微信公众号来举例，假设微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了程序猿这个公众号，当这个公众号更新时就会通知这些订阅的微信用户。好了我们来看看用代码如何实现：

抽象观察者（Observer）

里面定义了一个更新的方法：

1. interface Observe{  
2.     void upData(String message);  
3. }  

具体观察者（ConcrereObserver）

观察者，里面实现了更新的方法：

1. //观察者实现类  
2. public class ObserveRealize implements Observe{  
3.     private String name;  
4.   
5.     public ObserveRealize(String name) {  
6.         this.name = name;  
7.     }  
8.   
9.     @Override  
10.     public void upData(String message) {  
11. //        收到跟新信息  
12.         System.out.println(name+"收到的信息是："+message);  
13.     }  

抽象被观察者（Subject）

抽象主题，提供了attach、detach、notifyObserve三个方法：

1. //被观察者抽象借口  
2. interface Subject{  
3.     abstract void attach(Observe observe);  
4.     abstract void detach(Observe observe);  
5.     abstract void notifyObsever(String message);  
6. }  

具体被观察者（ConcreteSubject）

具体被观察者里面存储了订阅的观察者，并实现了抽象主题中的方法：

1. //被观察者实现类  
2. public class SubscriptRealize implements Subject{  
3.     private ArrayList<Observe> observeList;  
4.   
5.     public SubscriptRealize() {  
6.         this.observeList = new ArrayList<>();  
7.     }  
8.   
9.     @Override  
10.     public void attach(Observe observe) {  
11.         observeList.add(observe);  
12.     }  
13.   
14.     @Override  
15.     public void detach(Observe observe) {  
16.         observeList.remove(observe);  
17.     }  
18.   
19.     @Override  
20.     public void notifyObsever(String message) {  
21.         int length = observeList.size();  
22.         for (int i=0; i<length; i++){  
23.             observeList.get(i).upData(message);  
24.         }  
25.     }  
26. }  

3.使用观察者模式的场景和优缺点

使用场景

• 关联行为场景，需要注意的是，关联行为是可拆分的，而不是"组合"关系。
• 事件多级触发场景。
• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。