設計模式系列：觀察者模式(Observer)

觀察者模式(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>();// 用來保存註冊的觀察者對象   
    public void attach(Observer observer) {  
        list.add(observer);  
        System.out.println("Attached an 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 {  
       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);  
    }  
}  

推模型和拉模型

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

• 推模型。主題對象向觀察者推送主題的詳細信息，不管觀察者是否需要，推送的信息通常是主題對象的全部或部分數據。
• 拉模型。主題對象在通知觀察者的時候，只傳遞少量信息。如果觀察者需要更具體的信息，由觀察者主動到主題對象中獲取，相當於是觀察者從主題對象中拉數據。一般這種模型的實現中，會把主題對象自身通過update()方法傳遞給觀察者，這樣在觀察者需要獲取數據的時候，就可以通過這個引用來獲取了。

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

// @類說明：拉模型通常都是把主題對象當做參數傳遞。 
public interface Observer {  
      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);  
    }  
}  

兩種模式的比較

• 推模型是假定主題對象知道觀察者需要的數據；而拉模型是主題對象不知道觀察者具體需要什麼數據，沒有辦法的情況下，乾脆把自身傳遞給觀察者，讓觀察者自己去按需要取值。
• 推模型可能會使得觀察者對象難以複用，因爲觀察者的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()方法，從而使所有的觀察者都被通知更新自己。