《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()方法。