设计模式之Observer

观察者模式又被称为依赖(Dependents)或发布-订阅模式(Publish-Subscribe).

意图:  定义对象间的一种一对多的依赖关系, 当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新.

问题: 当某个事件发生时,你需要相一系列对象发出通知, 而这个对象的列表是变化的.

实现:

1.  让"希望知道某个事件何时发生"的对象(Observer)将自己注册到另一个"监视时间发生或自己触发事件"的对象(Subject)上.
2.  当事件发生时, Subject 告诉 Observer "你关心的事件已经发生了"
3.  为了能让所有的观察者型对象实现Observer接口,有时候需要使用Adapter模式.

示意图:

示例:

在Java包中容纳了Oberver模式的一个实现版本.Observable类和Observer接口组成了这个模式. Observable类扮演了Subject的角色,是被观察者, Observer是观察者的超类.

主题(被观察者):

java 代码

1. public class Observable {   
2.     private boolean changed = false;   
3.     //保存所有观察者   
4.     private Vector obs;   
5.       
6.     public Observable() {   
7.  obs = new Vector();   
8.     }   
9.     //注册一个观察者   
10.     public synchronized void addObserver(Observer o) {   
11.         if (o == null)   
12.             throw new NullPointerException();   
13.  if (!obs.contains(o)) {   
14.      obs.addElement(o);   
15.  }   
16.     }   
17.     //移除一个观察者   
18.     public synchronized void deleteObserver(Observer o) {   
19.         obs.removeElement(o);   
20.     }   
21.     //如果状态改变通知所有观察者   
22.     public void notifyObservers() {   
23.  notifyObservers(null);   
24.     }   
25.     //如果状态改变通知某个观察者   
26.     public void notifyObservers(Object arg) {   
27.  /*  
28.          * a temporary array buffer, used as a snapshot of the state of  
29.          * current Observers.  
30.          */  
31.         Object[] arrLocal;   
32.   
33.  synchronized (this) {   
34.      /* We don't want the Observer doing callbacks into  
35.       * arbitrary code while holding its own Monitor.  
36.       * The code where we extract each Observable from   
37.       * the Vector and store the state of the Observer  
38.       * needs synchronization, but notifying observers  
39.       * does not (should not).  The worst result of any   
40.       * potential race-condition here is that:  
41.       * 1) a newly-added Observer will miss a  
42.       *   notification in progress  
43.       * 2) a recently unregistered Observer will be  
44.       *   wrongly notified when it doesn't care  
45.       */  
46.      if (!changed)   
47.                 return;   
48.             arrLocal = obs.toArray();   
49.             clearChanged();   
50.         }   
51.   
52.         for (int i = arrLocal.length-1; i>=0; i--)   
53.             ((Observer)arrLocal[i]).update(this, arg);   
54.     }   
55.     //移除所有观察者   
56.     public synchronized void deleteObservers() {   
57.  obs.removeAllElements();   
58.     }   
59.     //设置状态改变   
60.     protected synchronized void setChanged() {   
61.  changed = true;   
62.     }   
63.     //设置状态未改变   
64.     protected synchronized void clearChanged() {   
65.  changed = false;   
66.     }   
67.     //判断状态是否改变   
68.     public synchronized boolean hasChanged() {   
69.  return changed;   
70.     }   
71.     //得到观察者数量   
72.     public synchronized int countObservers() {   
73.  return obs.size();   
74.     }   
75. }   

观察者超类:

java 代码

1.   
2. public interface Observer {   
3.     void update(Observable o, Object arg);   
4. }   

观察者扩展类:

java 代码

1.   
2. public class Observer1 implements Observer {   
3.     //注册观察主题, 这个可以在超类中实现   
4.     public void Observer1(){   
5.         Observable observable = new Observable();   
6.         observable.addObserver(this);   
7.     }   
8.     void update(Observable o, Object arg){   
9.         //do our bussiness ......   
10.         System.out.println("O has changed, I get it!");    
11.      }   
12. }   

 

示例2: 

        有一个系统, 不定时的收到很多信息,如天气预报, 体育新闻, 国际新闻, 最新歌曲等, 每次有新的信息到达时, 系统将这些信息发送给不同的订阅客户,这些客户都订阅了这些主题中的一个或多个. 客户也可以选择订阅和退定. 

这是一个典型的订阅/发布系统: 这些不同信息就相当于不同的主题(Subject), 不同内容的订阅客户就相当于观察者(Observer). 例子以后再写喽!