觀察者模式(設計模式)-轉

標籤：

《JAVA與模式》之觀察者模式

在閻宏博士的《JAVA與模式》一書中開頭是這樣描述觀察者（Observer）模式的：

　　觀察者模式是對象的行為模式，又叫發布-訂閱(Publish/Subscribe)模式、模型-視圖(Model/View)模式、源-監聽器(Source/Listener)模式或從屬者(Dependents)模式。

　　觀察者模式定義了一種一對多的依賴關係，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態上發生變化時，會通知所有觀察者對象，使它們能夠自動更新自己。

觀察者模式的結構

　　一個軟體系統裡麵包含了各種對象，就像一片欣欣向榮的森林充滿了各種生物一樣。在一片森林中，各種生物彼此依賴和約束，形成一個個生物鏈。一種生物的狀態變化會造成其他一些生物的相應行動，每一個生物都處於別的生物的互動之中。

　　同樣，一個軟體系統常常要求在某一個對象的狀態發生變化的時候，某些其他的對象做出相應的改變。做到這一點的設計方案有很多，但是為了使系統能夠易於複用，應該選擇低耦合度的設計方案。減少對象之間的耦合有利於系統的複用，但是同時設計師需要使這些低耦合度的對象之間能夠維持行動的協調一致，保證高度的協作。觀察者模式是滿足這一要求的各種設計方案中最重要的一種。

　　下面以一個簡單的示意性實現為例，討論觀察者模式的結構。

　　觀察者模式所涉及的角色有：

　　●　　抽象主題(Subject)角色：抽象主題角色把所有對觀察者對象的引用儲存在一個聚集（比如ArrayList對象）裡，每個主題都可以有任何數量的觀察者。抽象主題提供一個介面，可以增加和刪除觀察者對象，抽象主題角色又叫做抽象被觀察者(Observable)角色。

　　●　　具體主題(ConcreteSubject)角色：將有關狀態存入具體觀察者對象；在具體主題的內部狀態改變時，給所有登記過的觀察者發出通知。具體主題角色又叫做具體被觀察者(Concrete Observable)角色。

　　●　　抽象觀察者(Observer)角色：為所有的具體觀察者定義一個介面，在得到主題的通知時更新自己，這個介面叫做更新介面。

　　●　　具體觀察者(ConcreteObserver)角色：儲存與主題的狀態自恰的狀態。具體觀察者角色實現抽象觀察者角色所要求的更新介面，以便使本身的狀態與主題的狀態 像協調。如果需要，具體觀察者角色可以保持一個指向具體主題對象的引用。

　　原始碼

　　　　抽象主題角色類

public abstract class Subject {    /**     * 用來儲存註冊的觀察者對象     */    private    List<Observer> list = new ArrayList<Observer>();    /**     * 註冊觀察者對象     * @param observer    觀察者對象     */    public void attach(Observer observer){                list.add(observer);        System.out.println("Attached an observer");    }    /**     * 刪除觀察者對象     * @param observer    觀察者對象     */    public void detach(Observer observer){                list.remove(observer);    }    /**     * 通知所有註冊的觀察者對象     */    public void nodifyObservers(String newState){                for(Observer observer : list){            observer.update(newState);        }    }}

　　具體主題角色類

public class ConcreteSubject extends Subject{        private String state;        public String getState() {        return state;    }    public void change(String newState){        state = newState;        System.out.println("主題狀態為：" + state);        //狀態發生改變，通知各個觀察者        this.nodifyObservers(state);    }}

　　抽象觀察者角色類

public interface Observer {    /**     * 更新介面     * @param state    更新的狀態     */    public void update(String state);}

　　具體觀察者角色類

public class ConcreteObserver implements Observer {    //觀察者的狀態    private String observerState;        @Override    public void update(String state) {        /**         * 更新觀察者的狀態，使其與目標的狀態保持一致         */        observerState = state;        System.out.println("狀態為："+observerState);    }}

　　用戶端類

public class Client {    public static void main(String[] args) {        //建立主題對象        ConcreteSubject subject = new ConcreteSubject();        //建立觀察者對象        Observer observer = new ConcreteObserver();        //將觀察者對象登記到主題對象上        subject.attach(observer);        //改變主題對象的狀態        subject.change("new state");    }}

　　運行結果如下

　　在運行時，這個用戶端首先建立了具體主題類的執行個體，以及一個觀察者對象。然後，它調用主題對象的attach()方法，將這個觀察者對象向主題對象登記，也就是將它加入到主題對象的聚集中去。

　　這時，用戶端調用主題的change()方法，改變了主題對象的內部狀態。主題對象在狀態發生變化時，調用超類的notifyObservers()方法，通知所有登記過的觀察者對象。

推模型和拉模型

　　在觀察者模式中，又分為推模型和拉模型兩種方式。

　　●　　推模型

　　　　 主題對象向觀察者推送主題的詳細資料，不管觀察者是否需要，推送的資訊通常是主題對象的全部或部分資料。

　　●　　拉模型

　　　　 主題對象在通知觀察者的時候，只傳遞少量資訊。如果觀察者需要更具體的資訊，由觀察者主動到主題對象中擷取，相當於是觀察者從主題對象中拉資料。一般這種模型的實現中，會把主題對象自身通過update()方法傳遞給觀察者，這樣在觀察者需要擷取資料的時候，就可以通過這個引用來擷取了。

　　根據上面的描述，發現前面的例子就是典型的推模型，下面給出一個拉模型的執行個體。

　　拉模型的抽象觀察者類

　　拉模型通常都是把主題對象當做參數傳遞。

public interface Observer {    /**     * 更新介面     * @param subject 傳入主題對象，方面擷取相應的主題對象的狀態     */    public void update(Subject subject);}

　　拉模型的具體觀察者類

public class ConcreteObserver implements Observer {    //觀察者的狀態    private String observerState;        @Override    public void update(Subject subject) {        /**         * 更新觀察者的狀態，使其與目標的狀態保持一致         */        observerState = ((ConcreteSubject)subject).getState();        System.out.println("觀察者狀態為："+observerState);    }}

　　拉模型的抽象主題類

　　拉模型的抽象主題類主要的改變是nodifyObservers()方法。在迴圈通知觀察者的時候，也就是迴圈調用觀察者的update()方法的時候，傳入的參數不同了。

public abstract class Subject {    /**     * 用來儲存註冊的觀察者對象     */    private    List<Observer> list = new ArrayList<Observer>();    /**     * 註冊觀察者對象     * @param observer    觀察者對象     */    public void attach(Observer observer){                list.add(observer);        System.out.println("Attached an observer");    }    /**     * 刪除觀察者對象     * @param observer    觀察者對象     */    public void detach(Observer observer){                list.remove(observer);    }    /**     * 通知所有註冊的觀察者對象     */    public void nodifyObservers(){                for(Observer observer : list){            observer.update(this);        }    }}

　　拉模型的具體主題類

　　跟推模型相比，有一點變化，就是調用通知觀察者的方法的時候，不需要傳入參數了。

public class ConcreteSubject extends Subject{        private String state;        public String getState() {        return state;    }    public void change(String newState){        state = newState;        System.out.println("主題狀態為：" + state);        //狀態發生改變，通知各個觀察者        this.nodifyObservers();    }}

　　兩種模式的比較

　　■　　推模型是假定主題對象知道觀察者需要的資料；而拉模型是主題對象不知道觀察者具體需要什麼資料，沒有辦法的情況下，乾脆把自身傳遞給觀察者，讓觀察者自己去按需要取值。

　　■　　推模型可能會使得觀察者對象難以複用，因為觀察者的update()方法是按需要定義的參數，可能無法兼顧沒有考慮到的使用方式。這就意味著出現新情況的時候，就可能提供新的update()方法，或者是乾脆重新實現觀察者；而拉模型就不會造成這樣的情況，因為拉模型下，update()方法的參數是主題對象本身，這基本上是主題對象能傳遞的最大資料集合了，基本上可以適應各種情況的需要。

JAVA提供的對觀察者模式的支援

　　在JAVA語言的java.util庫裡面，提供了一個Observable類以及一個Observer介面，構成JAVA語言對觀察者模式的支援。

　　Observer介面

　　這個介面只定義了一個方法，即update()方法，當被觀察者對象的狀態發生變化時，被觀察者對象的notifyObservers()方法就會調用這一方法。

public interface Observer {    void update(Observable o, Object arg);}

　　Observable類

　　被觀察者類都是java.util.Observable類的子類。java.util.Observable提供公開的方法支援觀察者對象，這些方法中有兩個對Observable的子類非常重要：一個是setChanged()，另一個是notifyObservers()。第一方法setChanged()被調用之後會設定一個內部標記變數，代表被觀察者對象的狀態發生了變化。第二個是notifyObservers()，這個方法被調用時，會調用所有登記過的觀察者對象的update()方法，使這些觀察者對象可以更新自己。

public class Observable {    private boolean changed = false;    private Vector obs;       /** Construct an Observable with zero Observers. */    public Observable() {    obs = new Vector();    }    /**     * 將一個觀察者添加到觀察者聚集上面     */    public synchronized void addObserver(Observer o) {        if (o == null)            throw new NullPointerException();    if (!obs.contains(o)) {        obs.addElement(o);    }    }    /**     * 將一個觀察者從觀察者聚集上刪除     */    public synchronized void deleteObserver(Observer o) {        obs.removeElement(o);    }    public void notifyObservers() {    notifyObservers(null);    }    /**     * 如果本對象有變化（那時hasChanged 方法會返回true）     * 調用本方法通知所有登記的觀察者，即調用它們的update()方法     * 傳入this和arg作為參數     */    public void notifyObservers(Object arg) {        Object[] arrLocal;    synchronized (this) {        if (!changed)                return;            arrLocal = obs.toArray();            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            ((Observer)arrLocal[i]).update(this, arg);    }    /**     * 將觀察者聚集清空     */    public synchronized void deleteObservers() {    obs.removeAllElements();    }    /**     * 將“已變化”設定為true     */    protected synchronized void setChanged() {    changed = true;    }    /**     * 將“已變化”重設為false     */    protected synchronized void clearChanged() {    changed = false;    }    /**     * 檢測本對象是否已變化     */    public synchronized boolean hasChanged() {    return changed;    }    /**     * Returns the number of observers of this <tt>Observable</tt> object.     *     * @return  the number of observers of this object.     */    public synchronized int countObservers() {    return obs.size();    }}

　　這個類代表一個被觀察者對象，有時稱之為主題對象。一個被觀察者對象可以有數個觀察者對象，每個觀察者對象都是實現Observer介面的對象。在被觀察者發生變化時，會調用Observable的notifyObservers()方法，此方法調用所有的具體觀察者的update()方法，從而使所有的觀察者都被通知更新自己。

怎樣使用JAVA對觀察者模式的支援

　　這裡給出一個非常簡單的例子，說明怎樣使用JAVA所提供的對觀察者模式的支援。在這個例子中，被觀察對象叫做Watched；而觀察者對象叫做Watcher。Watched對象繼承自java.util.Observable類；而Watcher對象實現了java.util.Observer介面。另外有一個Test類扮演用戶端角色。

　　原始碼

　　被觀察者Watched類原始碼

public class Watched extends Observable{        private String data = "";        public String getData() {        return data;    }    public void setData(String data) {                if(!this.data.equals(data)){            this.data = data;            setChanged();        }        notifyObservers();    }        }

 

　　觀察者類原始碼

public class Watcher implements Observer{        public Watcher(Observable o){        o.addObserver(this);    }        @Override    public void update(Observable o, Object arg) {                System.out.println("狀態發生改變：" + ((Watched)o).getData());    }}

　　測試類別原始碼

public class Test {    public static void main(String[] args) {                //建立被觀察者對象        Watched watched = new Watched();        //建立觀察者對象，並將被觀察者對象登記        Observer watcher = new Watcher(watched);        //給被觀察者狀態賦值        watched.setData("start");        watched.setData("run");        watched.setData("stop");    }}

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

觀察者模式(設計模式)-轉