观察者模式 详解

什么时候需要观察者

答案是需要观察的时候（别喷我），观察的意思就是去看，看外界的状态，外界如果发生了某种变化，那观察外界的对象就执行其对应的操作，这种场景在现实应用中很常见，或者说整个社会就是在我观察你，你观察我这种机制下运行的。实际一点的例子：图形用户程序中，图形对象需要监视后台数据对象的变化来做响应的显示；再举一现在系统中常用的一个服务：短信推送服务，当用户发出了交易请求时，就给该用户发送一个短信验证码。

观察者模式

思考：为了实现观察者对外界对象变化做出响应，我们应该想到两种做法，一种是观察者以轮询的方式观察某一对象，当本次观察发现对象状态发生改变时就做出响应（这种效率太低，因为这意味着观察者在外界对象变化前不能做其他的事情）；第二种做法是异步通知的方式，当对象状态发生改变时，对象会向观察者发送消息（在代码中体现为它调用了观察者的某一方法），因为这不像进程间通信一样可以通过中断或者信号的方式实现，对象之间的异步通信只能通过调用彼此之间的方法。这意味着什么？这意味着外界对象必须拥有观察者的指针或者引用。即他们之间应该有聚合关系。

下面我们给出一个简单的实例代码，就以父母来观察孩子为场景

首先给出一个ChinaParent类的实现

[java]  view plain copy print ?

1. //观察者  
2. public class ChinaParent {  
3.       
4.     //孩子生病了他们会给孩子电话慰问  
5.     public void callChildren(){  
6.           
7.         System.out.println("回来吧，带你去看医生");  
8.     }  
9. }  

然后给出Children类的实现

[java]  view plain copy print ?

1. //被观察者  
2. public class ChinaChildren {  
3.       
4.     private ChinaParent p;  
5.       
6.     public void gotSick(){  
7.           
8.         p.callChildren();  
9.     }  
10. }  

ChinaChildren和ChinaParent是一种聚合关系，当孩子生病的时候会主动的调用观察这p的callChildren()方法，以表示通知了他的观察者。

但是这种观察者的实现方式很不好，因为我们在具体的实现类之间建立的很强的关联关系，我们需要对他们进行解耦，而面向对象中解耦的方法最好不过的是面向接口的设计方法了，所以我们给这两个对象都实现某一接口

[java]  view plain copy print ?

1. public interface Parent {  
2.       
3.     public void callChildren();  
4. }  

[java]  view plain copy print ?

1. public interface Children {  
2.       
3.     public void notifyParent();  
4. }  

然后具体的实现类实现对应的接口

[java]  view plain copy print ?

1. //观察者  
2. public class ChinaParent implements Parent{  
3.       
4.     //孩子生病了他们会给孩子电话慰问  
5.     public void callChildren(){  
6.           
7.         System.out.println("回来吧，带你去看医生");  
8.     }  
9. }  

[java]  view plain copy print ?

1. <pre code_snippet_id="267314" snippet_file_name="blog_20140331_6_1751525" name="code" class="java">//被观察者  
2. public class ChinaChildren implements Children{  
3.       
4.     private Parent p;  
5.       
6.     public void notifyParent() {  
7.           
8.         p.callChildren();  
9.     }  
10.       
11.     public void setObserver(Parent p){  
12.         this.p = p;  
13.     }  
14. }</pre><br>  
15. <br>  
16. <pre></pre>  
17. 这样就把孩子和具体的Parent解耦了，现在当有新类型的Parent时，我们也不用担心为了将新的观察者加入到我们的系统中而修改源码了。如：  

[java]  view plain copy print ?

1. //观察者  
2. public class AmericaParent implements Parent{  
3.       
4.     //孩子生病了他们会给孩子电话慰问  
5.     public void callChildren(){  
6.           
7.         System.out.println("自己去看医生");  
8.     }  
9. }  

到此为止其实你已经掌握了观察者模式的核心了，说白了就是用面向接口的方法将具体的观察者和被观察者对象解耦了，但是实际项目中我们还会发现对象往往可以由多个对象共同观察，所以被观察对象中应该有多个观察者的引用

首先我们改变Children接口

[java]  view plain copy print ?

1. public interface Children {  
2.       
3.     public void notifyAllParents();  
4.       
5. }  

然后修改对应的被观察者

[java]  view plain copy print ?

1. import java.util.ArrayList;  
2.   
3. //被观察者  
4. public class ChinaChildren implements Children{  
5.       
6.     private ArrayList<Parent> ps;  
7.       
8.     public void notifyAllParents() {  
9.           
10.         for(int i=0;i<ps.size();i++){  
11.               
12.             ps.get(i).callChildren();  
13.               
14.         }  
15.           
16.     }  
17.       
18.     public void addObserver(Parent p){  
19.         ps.add(p);  
20.     }  
21.       
22.     public void delObserver(Parent p){  
23.         ps.remove(p);  
24.     }  
25.       
26. }  

这种就是最常用的观察者模式了，其实就是实现了多观察者同时观察同一个对象，人们美其名曰：发布订阅。因为被观察对象给出了向该对象中注册新的观察者和删除已有观察者的接口。

四、总结

设计模式中有很多模式都是通过面向接口编程的思想来对强关联的对象之间解耦的，面向接口给我们的程序带来了更好的扩展性，而这种方法运用到不同的场景语义中便形成了不同的模式，也就是说很多模式不是技术上的不同（都是面向接口而已），而是将面向接口的思想运用在了不同的场景应用中而已。