觀察者模式
一、定義
二、結構
具體案例
推模型和拉模型 
三、Java提供的對觀察者模式的支援
Observer介面
Observable類

一、定義

觀察者模式是物件的行為模式，又叫釋出-訂閱(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");
    }

}

結果：
Attached an observe
主題狀態為： new  state
觀察者狀態為： new  state

在執行時，這個客戶端首先建立了具體主題類的例項，以及一個觀察者物件。然後，它呼叫主題物件的attach()方法，將這個觀察者物件向主題物件登記，也就是將它加入到主題物件的聚集中去。
這時，客戶端呼叫主題的change()方法，改變了主題物件的內部狀態。主題物件在狀態發生變化時，呼叫超類的notifyObservers()方法，通知所有登記過的觀察者物件。

具體案例

/*
 * 抽象觀察者角色  粉絲作為觀察者
 *  粉絲關注博主的部落格
 *  博主負責更新文章
 *   然後粉絲收到通知
 */
public interface  Observe {
    //粉絲收到最新文章資訊
    public void update(String article);
}

/**
 * 具體觀察者類  
 * 粉絲
 * @author Administrator
 *
 */
public class Fans implements Observe {
    private String articleInfo;

    @Override
    public void update(String article) {
        articleInfo=article;
        System.out.println("你關注的博主更新文章了 ！文章標題為 ："+articleInfo);
    }

}

/**
 * 抽象主題角色 
 * @author Administrator
 *
 */
public abstract class Subject {
    //用來註冊所有觀察者物件
    private List<Observe> obsevers=new ArrayList<Observe>();
    //新增觀察者
    public void addObsever(Observe observe){
        obsevers.add(observe);
    }
    //刪除觀察者
    public void removeObsever(Observe observe){
        obsevers.remove(observe);
    }
     /**
     * 通知所有註冊的觀察者物件
     */
    public void  nodifyObservers(String article){
        for(Observe observe:obsevers){
            observe.update(article);
        }
    }

}

/**
 * 具體主題角色  文章類
 * 他可以改變標題等
 * @author Administrator
 *
 */
public class Article extends Subject {
    private String article;

    public String getArticle() {
        return article;
    }

    public void setArticle(String article) {
        this.article = article;
        System.out.println("文章標題為："+article);
        //狀態發生改變，通知各個觀察者
        this.nodifyObservers(article);
    }

}

public class Client {
    public static void main(String[] args) {
        //建立主題
        Article s=new Article();
        //建立觀察者
        Observe obsever=new Fans();
        Observe obsever1=new Fans();
        //新增觀察者
        s.addObsever(obsever);
        s.addObsever(obsever1);
        s.setArticle("我的第一篇部落格");

    }
}

結果：
文章標題為：我的第一篇部落格
你關注的博主更新文章了 ！文章標題為 ：我的第一篇部落格
你關注的博主更新文章了 ！文章標題為 ：我的第一篇部落格

推模型和拉模型
　　在觀察者模式中，又分為推模型和拉模型兩種方式。
　　●　　推模型
　　　　 主題物件向觀察者推送主題的詳細資訊，不管觀察者是否需要，推送的資訊通常是主題物件的全部或部分資料。
　　●　　拉模型
　　　　 主題物件在通知觀察者的時候，只傳遞少量資訊。如果觀察者需要更具體的資訊，由觀察者主動到主題物件中獲取，相當於是觀察者從主題物件中拉資料。一般這種 模型的實現中，會把主題物件自身通過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();
    }
}

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

三、Java提供的對觀察者模式的支援
　　在JAVA語言的java.util庫裡面，提供了一個Observable類以及一個Observer介面，構成JAVA語言對觀察者模式的支援。
　
Observer介面
　　這個介面只定義了一個方法，即update()方法，當被觀察者物件的狀態發生變化時，被觀察者物件的notifyObservers()方法就會呼叫這一方法。
　　
JDK原始碼：

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對觀察者模式的支援
例子同上
被觀察者類原始碼

public class Article extends  Observable {
    private String article;

    public String getArticle() {
        return article;
    }

    public void setArticle(String article) {
        this.article = article;
        System.out.println("文章標題為："+article);
        //狀態為狀態改變，通知各個觀察者
          setChanged();
          notifyObservers(article);
    }
}

觀察者類原始碼

public class Fans implements Observer {
    private String articleInfo;

    @Override
    public void update(Observable observe, Object article) {
        articleInfo=article.toString();
        System.out.println("你關注的博主更新文章了 ！文章標題為 ："+articleInfo);
    }

}

測試類原始碼

public class Client {
    public static void main(String[] args) {
        Article a=new Article();
        Fans obsever=new Fans();
        Fans obsever1=new Fans();
        a.addObserver(obsever);
        a.addObserver(obsever1);
        a.setArticle("我寫了一篇部落格");
    }
}

結果：同上
文章標題為：我寫了一篇部落格
你關注的博主更新文章了 ！文章標題為 ：我寫了一篇部落格
你關注的博主更新文章了 ！文章標題為 ：我寫了一篇部落格