观察者模式

观察者模式的核心就是让行为的行使着变主动为被动。行为的行使着就是观察者。

http://blog.csdn.net/sundacheng1989/article/details/50285369

本篇文章总结于马士兵的视频教程《观察者模式》。个人非常推荐马士兵的视频教程，对于初学Java的人来说，J2SE基础视频非常不错，对于内存分析讲的十分到位。对于有一定基础的人来说，设计模式系列，反射系列，正则表达式系列都非常不错，不仅仅局限于Java,而C#学习者也可以看一看。

 

这里通过一个生活例子来讲观察者模式。这个场景就是，有一个小孩在睡觉，然后他老爸在旁边，小孩醒了他老爸就要喂他吃东西。从面相对象的角度来讲，我们通过描述就可以抽象出实体类，小孩，老爸是两个对象，然后睡觉是小孩的状态，喂东西是老爸的方法。

 

第一种方法，我们用最直接的方式去模拟这个过程。当小孩在睡觉的时候，老爸会一直的去查看小孩是否醒了，1秒钟查看一次，模拟到程序里边，就是一种死循环，以轮循的方式去判断小孩的属性。这里把小孩设计成一个线程，最初是睡着状态，10秒后醒来。那么10秒后老爸就要调用其feed方法。小孩的toString()方法输出这个对象的唯一标识，表示这个特定的小孩。

[java] view plain copy

1. package com.robin.test;  
2.   
3. import java.io.IOException;  
4.   
5. public class Main {  
6.   
7.     public static void main(String[] args) throws IOException {  
8.         Baby b = new Baby();  
9.         Dad d = new Dad(b);  
10.         new Thread(d).start();  
11.         new Thread(b).start();  
12.           
13.         System.in.read();  
14.     }  
15.   
16. }  
17.   
18. class Baby implements Runnable {  
19.       
20.     private boolean wakeUp = false;  
21.       
22.     public boolean isWakeUp() {  
23.         return wakeUp;  
24.     }  
25.       
26.     void wakeUp() {  
27.         wakeUp = true;  
28.     }  
29.   
30.     @Override  
31.     public void run() {  
32.         try {  
33.             Thread.sleep(1000 * 10);  
34.             this.wakeUp();  
35.         }  
36.         catch (Exception ex) {  
37.             ex.printStackTrace();  
38.         }  
39.     }  
40. }  
41.   
42.   
43. class Dad implements Runnable {  
44.       
45.     Baby baby;  
46.       
47.     private void feedBaby() {  
48.         System.out.println("Feed the baby..." + baby.toString());  
49.     }  
50.       
51.     public Dad(Baby baby) {  
52.         this.baby = baby;  
53.     }  
54.   
55.     @Override  
56.     public void run() {  
57.         while(true)  
58.         {  
59.             if(baby.isWakeUp() == true) {  
60.                 feedBaby();   
61.             }  
62.         }  
63.     }  
64.       
65.       
66.       
67. }  

这种方式存在一定的弊端，即老爸得时时刻刻盯着小孩，这个过程中不能干别的事情，即使客厅里有足球赛，这时候老爸也不能把小孩放在房间里自己去客厅。反应到程序中来讲，这种死循环的方式，对于CPU是一种无端的消耗。 

 

接下来我们用第二种方式进行模拟。我们可以这样，我们让小孩持有老爸的引用，当小孩醒了之后，主动调用老爸的feed方法。就相当于在小孩与老爸之间绑了一根绳子，小孩在里屋睡觉，老爸在客厅看球，当小孩醒了之后，拽动这个绳子，那么老爸得知消息后再进里屋来喂东西。代码可以如下。

[java] view plain copy

1. package com.robin.test;  
2.   
3. import java.io.IOException;  
4.   
5. public class Main {  
6.   
7.     public static void main(String[] args) throws IOException {  
8.         Dad d = new Dad();  
9.         Baby b = new Baby(d);  
10.           
11.         new Thread(b).start();  
12.           
13.         System.in.read();  
14.     }  
15.   
16. }  
17.   
18. class Baby implements Runnable {  
19.       
20.     private boolean wakeUp = false;  
21.     private Dad dad;  
22.       
23.     public boolean isWakeUp() {  
24.         return wakeUp;  
25.     }  
26.       
27.     void wakeUp() {  
28.         wakeUp = true;  
29.     }  
30.       
31.     public Baby(Dad dad) {  
32.         this.dad = dad;  
33.     }  
34.       
35.   
36.     @Override  
37.     public void run() {  
38.         try {  
39.             Thread.sleep(1000 * 10);  
40.             this.wakeUp();  
41.             dad.feedBaby();  
42.         }  
43.         catch (Exception ex) {  
44.             ex.printStackTrace();  
45.         }  
46.     }  
47. }  
48.   
49.   
50. class Dad {  
51.       
52.     public void feedBaby() {  
53.         System.out.println("Feed the baby...");  
54.     }  
55. }  

其实，到这种实现方法，我们已经引入了观察者模式。观察者模式的核心就是让行为的行使着变主动为被动。行为的行使着就是观察者。但是从面向对象的角度来讲，有些地方我们还可以接着完善。比如说，小孩什么时候醒的，这个属性不是小孩的，也不是老爸的，而是发生的这件事情本身的，所以醒来这件事应该也是一个类。所以接下来，我们完善一下代码，用第三种方式实现。

[java] view plain copy

1. package com.robin.test;  
2.   
3. import java.io.IOException;  
4.   
5. public class Main {  
6.   
7.     public static void main(String[] args) throws IOException {  
8.         Dad d = new Dad();  
9.         Baby b = new Baby(d);  
10.         new Thread(b).start();  
11.         System.in.read();  
12.     }  
13.   
14. }  
15.   
16. class Baby implements Runnable {  
17.       
18.     private boolean wakeUp = false;  
19.     private Dad dad;  
20.       
21.     public boolean isWakeUp() {  
22.         return wakeUp;  
23.     }  
24.     void wakeUp() {  
25.         wakeUp = true;  
26.     }  
27.     public Baby(Dad dad) {  
28.         this.dad = dad;  
29.     }  
30.       
31.     @Override  
32.     public void run() {  
33.         try {  
34.             Thread.sleep(1000 * 10);  
35.             this.wakeUp();  
36.             WakeUpEvent wakeUpEvent = new WakeUpEvent(System.currentTimeMillis(), "Home");  
37.             dad.ActionToWakeUp(wakeUpEvent);  
38.         }  
39.         catch (Exception ex) {  
40.             ex.printStackTrace();  
41.         }  
42.     }  
43. }  
44.   
45.   
46. class Dad {  
47.     public void ActionToWakeUp(WakeUpEvent event) {  
48.         System.out.println("Feed the baby..." + event.getHappenTime() + event.getLocation());  
49.     }  
50. }  
51.   
52. class WakeUpEvent {  
53.       
54.     private long happenTime;  
55.     public long getHappenTime() {  
56.         return happenTime;  
57.     }  
58.     public String getLocation() {  
59.         return location;  
60.     }  
61.     private String location;  
62.       
63.     public WakeUpEvent(long happenTime, String location) {  
64.         this.happenTime = happenTime;  
65.         this.location = location;  
66.     }  
67.       
68. }  

这里如果我们要求小孩的老妈也要对小孩的醒来进行一个些反应，我们就要修改小孩内部的代码，让小孩同时也持有老妈的引用。面向对象的一个重要原则就是添加而不是修改，就是说可以向小孩添加监听者，而不应该修改小孩的内部代码。所以，现在我们可以让所有的监听者实现同一个接口。而小孩内部持有这个接口的集合，那么就可以添加无数的监听者了。

[cpp] view plain copy

1. package com.robin.test;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. public class Main {  
8.   
9.     public static void main(String[] args) throws IOException {  
10.         Dad d = new Dad();  
11.         Mom m = new Mom();  
12.         Baby b = new Baby();  
13.         b.getList().add(m);  
14.         b.getList().add(d);  
15.         new Thread(b).start();  
16.         System.in.read();  
17.     }  
18.   
19. }  
20.   
21. class Baby implements Runnable {  
22.       
23.     private boolean wakeUp = false;  
24.     private List<BabyObserver> list;  
25.       
26.     public List<BabyObserver> getList() {  
27.         return list;  
28.     }  
29.       
30.     public boolean isWakeUp() {  
31.         return wakeUp;  
32.     }  
33.     void wakeUp() {  
34.         wakeUp = true;  
35.     }  
36.       
37.     public Baby() {  
38.         this.list = new ArrayList<BabyObserver>();  
39.     }  
40.       
41.     @Override  
42.     public void run() {  
43.         try {  
44.             Thread.sleep(1000 * 10);  
45.             this.wakeUp();  
46.             WakeUpEvent wakeUpEvent = new WakeUpEvent(System.currentTimeMillis(), "Home");  
47.             for(int i=0; i<list.size(); i++) {  
48.                 BabyObserver observer = list.get(i);  
49.                 observer.ActionToWakeUp(wakeUpEvent);  
50.             }  
51.         }  
52.         catch (Exception ex) {  
53.             ex.printStackTrace();  
54.         }  
55.     }  
56. }  
57.   
58.   
59. interface BabyObserver {  
60.     void ActionToWakeUp(WakeUpEvent event);  
61. }  
62.   
63. class Dad implements BabyObserver{  
64.     @Override  
65.     public void ActionToWakeUp(WakeUpEvent event) {  
66.         System.out.println("Dad Feed the baby..." + event.getHappenTime() + event.getLocation());  
67.     }  
68. }  
69.   
70. class Mom implements BabyObserver{  
71.     @Override  
72.     public void ActionToWakeUp(WakeUpEvent event) {  
73.         System.out.println("Mom Feed the baby..." + event.getHappenTime() + event.getLocation());  
74.     }  
75. }  
76.   
77. class WakeUpEvent {  
78.       
79.     private long happenTime;  
80.     public long getHappenTime() {  
81.         return happenTime;  
82.     }  
83.     public String getLocation() {  
84.         return location;  
85.     }  
86.     private String location;  
87.       
88.     public WakeUpEvent(long happenTime, String location) {  
89.         this.happenTime = happenTime;  
90.         this.location = location;  
91.     }  
92.       
93. }  
94.       

所以，最后这版的代码既实现了观察者模式，又有良好的可扩展性。综合来讲，使用观察者模式最大的好处就是减少死循环式的轮循带来的资源无端消耗，并且有着良好的可扩展性。

 

最后，说一点Java自身一个典型的观察者模式的实现，那就是AWT的Button等GUI的事件监听机制。对于鼠标点击或者键盘输入，Windows操作系统采用的是一种事件派发的机制，操作系统有一个GUI的监听进程，这个进程会不断的监听硬件给的反馈，比如说鼠标点击了一下，或者键盘按了那个字母键。这种行为被操作系统的这个进程捕捉到了以后，它检查到这个事件是哪个具体的程序的，比如说是个AWT程序的，操作系统会告诉虚拟机，鼠标按下了，你进行处理吧。虚拟机有个专门的线程来进行事件处理，这个线程拥有所有的AWT的GUI对象，比如说Button等，都拥有其引用。这个线程接到操作系统的信号后，会把这些信息封装成为一个ActionEvent类，然后检查一下点击了哪个组件，发现是button,就会调用button注册的那些方法。而button注册的那些方法，都是实现了同一个接口，所以button中有一个list,可以注册无数多的接口，而这些接口的具体内容可以由我们自己实现。这种设计有非常好的可扩展性。

 

综合上边，就是button作为一个观察者，没有时时刻刻监听着鼠标与键盘事件，也没有时时刻刻死循环的去询问操作系统有没有针对自己的点击，而是把自己的引用交给了虚拟机专门的GUI线程，而自己该干嘛干嘛，没有阻塞到这里。