《JAVA與模式》第18天—觀察者模式 – JAVA編程語言程序開發技術文章

 觀察者模式是對象的行為模式,又叫發佈-訂閱(Publish/Subscribe)模式、模型-視圖(Model/View)模式、源-監聽器(Source/Listener)模式或從屬者(Dependents)模式。
  觀察者模式定義瞭一種一對多的依賴關系,讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態上發生變化時,會通知所有觀察者對象,使它們能夠自動更新自己。
________________________________________
 
觀察者模式的結構
  一個軟件系統裡面包含瞭各種對象,就像一片欣欣向榮的森林充滿瞭各種生物一樣。在一片森林中,各種生物彼此依賴和約束,形成一個個生物鏈。一種生物的狀態變化會造成其他一些生物的相應行動,每一個生物都處於別的生物的互動之中。
  同樣,一個軟件系統常常要求在某一個對象的狀態發生變化的時候,某些其他的對象做出相應的改變。做到這一點的設計方案有很多,但是為瞭使系統能夠易於復用,應該選擇低耦合度的設計方案。減少對象之間的耦合有利於系統的復用,但是同時設計師需要使這些低耦合度的對象之間能夠維持行動的協調一致,保證高度的協作。觀察者模式是滿足這一要求的各種設計方案中最重要的一種。
  下面以一個簡單的示意性實現為例,討論觀察者模式的結構。
 

 觀察者模式所涉及的角色有:
  ●  抽象主題(Subject)角色:抽象主題角色把所有對觀察者對象的引用保存在一個聚集(比如ArrayList對象)裡,每個主題都可以有任何數量的觀察者。抽象主題提供一個接口,可以增加和刪除觀察者對象,抽象主題角色又叫做抽象被觀察者(Observable)角色。
  ●  具體主題(ConcreteSubject)角色:將有關狀態存入具體觀察者對象;在具體主題的內部狀態改變時,給所有登記過的觀察者發出通知。具體主題角色又叫做具體被觀察者(Concrete Observable)角色。
  ●  抽象觀察者(Observer)角色:為所有的具體觀察者定義一個接口,在得到主題的通知時更新自己,這個接口叫做更新接口。
  ●  具體觀察者(ConcreteObserver)角色:存儲與主題的狀態自恰的狀態。具體觀察者角色實現抽象觀察者角色所要求的更新接口,以便使本身的狀態與主題的狀態 像協調。如果需要,具體觀察者角色可以保持一個指向具體主題對象的引用。
  源代碼
    抽象主題角色類
[java] 
1. package com.bankht.Observer; 
2.  
3. import java.util.ArrayList; 
4. import java.util.List; 
5.  
6. /**
7.  * @author: 特種兵—AK47
8.  * @創建時間:2012-6-28 下午09:43:26
9.  * 
10.  * @類說明 :抽象主題角色類
11.  */ 
12. public abstract class Subject { 
13.     /**
14.      * 用來保存註冊的觀察者對象
15.      */ 
16.     private List<Observer> list = new ArrayList<Observer>(); 
17.  
18.     /**
19.      * 註冊觀察者對象
20.      * 
21.      * @param observer
22.      *            觀察者對象
23.      */ 
24.     public void attach(Observer observer) { 
25.  
26.         list.add(observer); 
27.         System.out.println("Attached an observer"); 
28.     } 
29.  
30.     /**
31.      * 刪除觀察者對象
32.      * 
33.      * @param observer
34.      *            觀察者對象
35.      */ 
36.     public void detach(Observer observer) { 
37.  
38.         list.remove(observer); 
39.     } 
40.  
41.     /**
42.      * 通知所有註冊的觀察者對象
43.      */ 
44.     public void nodifyObservers(String newState) { 
45.  
46.         for (Observer observer : list) { 
47.             observer.update(newState); 
48.         } 
49.     } 
50. } 
 

 
  具體主題角色類
[java] 
1. package com.bankht.Observer; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午09:44:36
6.  * 
7.  * @類說明 :具體主題角色類
8.  */ 
9. public class ConcreteSubject extends Subject { 
10.  
11.     private String state; 
12.  
13.     public String getState() { 
14.         return state; 
15.     } 
16.  
17.     public void change(String newState) { 
18.         state = newState; 
19.         System.out.println("主題狀態為:" + state); 
20.         // 狀態發生改變,通知各個觀察者  
21.         this.nodifyObservers(state); 
22.     } 
23. } 
 

 
  抽象觀察者角色類
[java] 
1. package com.bankht.Observer; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午09:45:20
6.  * 
7.  * @類說明 : 抽象觀察者角色類
8.  */ 
9. public interface Observer { 
10.     /**
11.      * 更新接口
12.      * 
13.      * @param state
14.      *            更新的狀態
15.      */ 
16.     public void update(String state); 
17. } 
 

 
  具體觀察者角色類
[java] 
1. package com.bankht.Observer; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午09:45:58
6.  * 
7.  * @類說明 :具體觀察者角色類
8.  */ 
9. public class ConcreteObserver implements Observer { 
10.     // 觀察者的狀態  
11.     private String observerState; 
12.  
13.     @Override 
14.     public void update(String state) { 
15.         /**
16.          * 更新觀察者的狀態,使其與目標的狀態保持一致
17.          */ 
18.         observerState = state; 
19.         System.out.println("狀態為:" + observerState); 
20.     } 
21.  
22. } 
 

 
  客戶端類
[java] 
1. package com.bankht.Observer; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午09:56:04
6.  * 
7.  * @類說明 :客戶端類
8.  */ 
9. public class Client { 
10.  
11.     public static void main(String[] args) { 
12.         // 創建主題對象  
13.         ConcreteSubject subject = new ConcreteSubject(); 
14.         // 創建觀察者對象  
15.         Observer observer = new ConcreteObserver(); 
16.         // 將觀察者對象登記到主題對象上  
17.         subject.attach(observer); 
18. //      subject.detach(observer);  
19.         // 改變主題對象的狀態  
20.         subject.change("new state"); 
21.     } 
22.  
23. } 
 

 運行結果如下:
[html] 
1. Attached an observer 
2. 主題狀態為:new state 
3. 狀態為:new state 
 

 
  在運行時,這個客戶端首先創建瞭具體主題類的實例,以及一個觀察者對象。然後,它調用主題對象的attach()方法,將這個觀察者對象向主題對象登記,也就是將它加入到主題對象的聚集中去。
  這時,客戶端調用主題的change()方法,改變瞭主題對象的內部狀態。主題對象在狀態發生變化時,調用超類的notifyObservers()方法,通知所有登記過的觀察者對象。
推模型和拉模型
  在觀察者模式中,又分為推模型和拉模型兩種方式。
  ●  推模型
     主題對象向觀察者推送主題的詳細信息,不管觀察者是否需要,推送的信息通常是主題對象的全部或部分數據。
  ●  拉模型
     主題對象在通知觀察者的時候,隻傳遞少量信息。如果觀察者需要更具體的信息,由觀察者主動到主題對象中獲取,相當於是觀察者從主題對象中拉數據。一般這種模型的實現中,會把主題對象自身通過update()方法傳遞給觀察者,這樣在觀察者需要獲取數據的時候,就可以通過這個引用來獲取瞭。
  根據上面的描述,發現前面的例子就是典型的推模型,下面給出一個拉模型的實例。
  拉模型的抽象觀察者類
  拉模型通常都是把主題對象當做參數傳遞。
[java] 
1. package com.bankht.Observer.pull; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午10:03:02
6.  * 
7.  * @類說明 :拉模型通常都是把主題對象當做參數傳遞。
8.  */ 
9. public interface Observer { 
10.     /**
11.      * 更新接口
12.      * 
13.      * @param subject
14.      *            傳入主題對象,方面獲取相應的主題對象的狀態
15.      */ 
16.     public void update(Subject subject); 
17. } 
 

 
  拉模型的具體觀察者類
[java] 
1. package com.bankht.Observer.pull; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午10:03:25
6.  * 
7.  * @類說明 : 拉模型的具體觀察者類
8.  */ 
9. public class ConcreteObserver implements Observer { 
10.     // 觀察者的狀態  
11.     private String observerState; 
12.  
13.     @Override 
14.     public void update(Subject subject) { 
15.         /**
16.          * 更新觀察者的狀態,使其與目標的狀態保持一致
17.          */ 
18.         observerState = ((ConcreteSubject) subject).getState(); 
19.         System.out.println("觀察者狀態為:" + observerState); 
20.     } 
21.  
22. } 
 

 
  拉模型的抽象主題類
  拉模型的抽象主題類主要的改變是nodifyObservers()方法。在循環通知觀察者的時候,也就是循環調用觀察者的update()方法的時候,傳入的參數不同瞭。
[java] 
1. package com.bankht.Observer.pull; 
2.  
3. import java.util.ArrayList; 
4. import java.util.List; 
5.  
6. /**
7.  * @author: 特種兵—AK47
8.  * @創建時間:2012-6-28 下午10:03:48
9.  * 
10.  * @類說明 
11.  *      :拉模型的抽象主題類主要的改變是nodifyObservers()方法。在循環通知觀察者的時候,也就是循環調用觀察者的update()方法的時候,
12.  *      傳入的參數不同瞭。
13.  */ 
14. public abstract class Subject { 
15.     /**
16.      * 用來保存註冊的觀察者對象
17.      */ 
18.     private List<Observer> list = new ArrayList<Observer>(); 
19.  
20.     /**
21.      * 註冊觀察者對象
22.      * 
23.      * @param observer
24.      *            觀察者對象
25.      */ 
26.     public void attach(Observer observer) { 
27.  
28.         list.add(observer); 
29.         System.out.println("Attached an observer"); 
30.     } 
31.  
32.     /**
33.      * 刪除觀察者對象
34.      * 
35.      * @param observer
36.      *            觀察者對象
37.      */ 
38.     public void detach(Observer observer) { 
39.  
40.         list.remove(observer); 
41.     } 
42.  
43.     /**
44.      * 通知所有註冊的觀察者對象
45.      */ 
46.     public void nodifyObservers() { 
47.  
48.         for (Observer observer : list) { 
49.             observer.update(this); 
50.         } 
51.     } 
52. } 
 

 
  拉模型的具體主題類
  跟推模型相比,有一點變化,就是調用通知觀察者的方法的時候,不需要傳入參數瞭。
[java] 
1. package com.bankht.Observer.pull; 
2.  
3. /**
4.  * @author: 特種兵—AK47
5.  * @創建時間:2012-6-28 下午10:04:24
6.  * 
7.  * @類說明 :跟推模型相比,有一點變化,就是調用通知觀察者的方法的時候,不需要傳入參數瞭。
8.  */ 
9. public class ConcreteSubject extends Subject { 
10.  
11.     private String state; 
12.  
13.     public String getState() { 
14.         return state; 
15.     } 
16.  
17.     public void change(String newState) { 
18.         state = newState; 
19.         System.out.println("主題狀態為:" + state); 
20.         // 狀態發生改變,通知各個觀察者  
21.         this.nodifyObservers(); 
22.     } 
23. } 
 

還是用剛才的Client.java 測試一下:
[html] 
1. Attached an observer 
2. 主題狀態為:new state 
3. 觀察者狀態為:new state 
 

 
  兩種模式的比較
  ■  推模型是假定主題對象知道觀察者需要的數據;而拉模型是主題對象不知道觀察者具體需要什麼數據,沒有辦法的情況下,幹脆把自身傳遞給觀察者,讓觀察者自己去按需要取值。
  ■  推模型可能會使得觀察者對象難以復用,因為觀察者的update()方法是按需要定義的參數,可能無法兼顧沒有考慮到的使用情況。這就意味著出現新情況的時候,就可能提供新的update()方法,或者是幹脆重新實現觀察者;而拉模型就不會造成這樣的情況,因為拉模型下,update()方法的參數是主題對象本身,這基本上是主題對象能傳遞的最大數據集合瞭,基本上可以適應各種情況的需要。
 
JAVA提供的對觀察者模式的支持
  在JAVA語言的java.util庫裡面,提供瞭一個Observable類以及一個Observer接口,構成JAVA語言對觀察者模式的支持。
  Observer接口
  這個接口隻定義瞭一個方法,即update()方法,當被觀察者對象的狀態發生變化時,被觀察者對象的notifyObservers()方法就會調用這一方法。
[java] 
1. public interface Observer { 
2.  
3.     void update(Observable o, Object arg); 
4. } 
 

 
  Observable類
  被觀察者類都是java.util.Observable類的子類。java.util.Observable提供公開的方法支持觀察者對象,這些方法中有兩個對Observable的子類非常重要:一個是setChanged(),另一個是notifyObservers()。第一方法setChanged()被調用之後會設置一個內部標記變量,代表被觀察者對象的狀態發生瞭變化。第二個是notifyObservers(),這個方法被調用時,會調用所有登記過的觀察者對象的update()方法,使這些觀察者對象可以更新自己。
[java] 
1. public class Observable { 
2.     private boolean changed = false; 
3.     private Vector obs; 
4.     
5.     /** Construct an Observable with zero Observers. */ 
6.  
7.     public Observable() { 
8.     obs = new Vector(); 
9.     } 
10.  
11.     /**
12.      * 將一個觀察者添加到觀察者聚集上面
13.      */ 
14.     public synchronized void addObserver(Observer o) { 
15.         if (o == null) 
16.             throw new NullPointerException(); 
17.     if (!obs.contains(o)) { 
18.         obs.addElement(o); 
19.     } 
20.     } 
21.  
22.     /**
23.      * 將一個觀察者從觀察者聚集上刪除
24.      */ 
25.     public synchronized void deleteObserver(Observer o) { 
26.         obs.removeElement(o); 
27.     } 
28.  
29.     public void notifyObservers() { 
30.     notifyObservers(null); 
31.     } 
32.  
33.     /**
34.      * 如果本對象有變化(那時hasChanged 方法會返回true)
35.      * 調用本方法通知所有登記的觀察者,即調用它們的update()方法
36.      * 傳入this和arg作為參數
37.      */ 
38.     public void notifyObservers(Object arg) { 
39.  
40.         Object[] arrLocal; 
41.  
42.     synchronized (this) { 
43.  
44.         if (!changed) 
45.                 return; 
46.             arrLocal = obs.toArray(); 
47.             clearChanged(); 
48.         } 
49.  
50.         for (int i = arrLocal.length-1; i>=0; i–) 
51.             ((Observer)arrLocal[i]).update(this, arg); 
52.     } 
53.  
54.     /**
55.      * 將觀察者聚集清空
56.      */ 
57.     public synchronized void deleteObservers() { 
58.     obs.removeAllElements(); 
59.     } 
60.  
61.     /**
62.      * 將“已變化”設置為true
63.      */ 
64.     protected synchronized void setChanged() { 
65.     changed = true; 
66.     } 
67.  
68.     /**
69.      * 將“已變化”重置為false
70.      */ 
71.     protected synchronized void clearChanged() { 
72.     changed = false; 
73.     } 
74.  
75.     /**
76.      * 檢測本對象是否已變化
77.      */ 
78.     public synchronized boolean hasChanged() { 
79.     return changed; 
80.     } 
81.  
82.     /**
83.      * Returns the number of observers of this <tt>Observable</tt> object.
84.      *
85.      * @return  the number of observers of this object.
86.      */ 
87.     public synchronized int countObservers() { 
88.     return obs.size(); 
89.     } 
90. } 
 

 
  這個類代表一個被觀察者對象,有時稱之為主題對象。一個被觀察者對象可以有數個觀察者對象,每個觀察者對象都是實現Observer接口的對象。在被觀察者發生變化時,會調用Observable的notifyObservers()方法,此方法調用所有的具體觀察者的update()方法,從而使所有的觀察者都被通知更新自己。
怎樣使用JAVA對觀察者模式的支持
  這裡給出一個非常簡單的例子,說明怎樣使用JAVA所提供的對觀察者模式的支持。在這個例子中,被觀察對象叫做Watched;而觀察者對象叫做Watcher。Watched對象繼承自java.util.Observable類;而Watcher對象實現瞭java.util.Observer接口。另外有一個Test類扮演客戶端角色。
  源代碼
  被觀察者Watched類源代碼
[java] 
1. package com.bankht.Observer.java; 
2.  
3. import java.util.Observable; 
4.  
5. /**
6.  * @author: 特種兵—AK47
7.  * @創建時間:2012-6-28 下午10:23:14
8.  * 
9.  * @類說明 :被觀察者Watched類源代碼
10.  */ 
11. public class Watched extends Observable { 
12.  
13.     private String data = ""; 
14.  
15.     public String getData() { 
16.         return data; 
17.     } 
18.  
19.     public void setData(String data) { 
20.  
21.         if (!this.data.equals(data)) { 
22.             this.data = data; 
23.             setChanged(); 
24.         } 
25.         notifyObservers(); 
26.     } 
27.  
28. } 
 

 觀察者類源代碼
[java]
1. package com.bankht.Observer.java; 
2.  
3. import java.util.Observable; 
4. import java.util.Observer; 
5.  
6.  
7. /**
8.  * @author: 特種兵—AK47
9.  * @創建時間:2012-6-28 下午10:23:44
10.  * 
11.  * @類說明 : 觀察者類源代碼
12.  */ 
13. public class Watcher implements Observer { 
14.  
15.     public Watcher(Observable o) { 
16.         o.addObserver(this); 
17.     } 
18.  
19.     @Override 
20.     public void update(Observable o, Object arg) { 
21.  
22.         System.out.println("狀態發生改變:" + ((Watched) o).getData()); 
23.     } 
24.  
25. } 
 

 測試類源代碼
[java] 
1. package com.bankht.Observer.java; 
2.  
3.  
4. /**
5.  * @author: 特種兵—AK47
6.  * @創建時間:2012-6-28 下午10:25:43
7.  * 
8.  * @類說明 :測試類源代碼
9.  */ 
10. public class Test { 
11.  
12.     public static void main(String[] args) { 
13.  
14.         // 創建被觀察者對象  
15.         Watched watched = new Watched(); 
16.         // 創建觀察者對象,並將被觀察者對象登記  
17.         new Watcher(watched); 
18.         // 給被觀察者狀態賦值  
19.         watched.setData("start"); 
20.         watched.setData("run"); 
21.         watched.setData("stop"); 
22.  
23.     } 
24.  
25. } 
 

 
  Test對象首先創建瞭Watched和Watcher對象。在創建Watcher對象時,將Watched對象作為參數傳入;然後Test對象調用Watched對象的setData()方法,觸發Watched對象的內部狀態變化;Watched對象進而通知實現登記過的Watcher對象,也就是調用它的update()方法。
 

 作者:m13666368773
 

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。