設計模式之觀察者模式

觀察者模式也叫發佈訂閱模式，它是一個在項目中經常使用的模式，定義如下：

 

定義對象間一種一對多的依賴關係，是的每當一個對象改變狀態，所有依賴它的對象都會得到通知並被自動更新

 

觀察者模式通用類圖：

 

 通過類圖看到觀察者模式涉及到如下四種角色：

1.Subject 被觀察者

定義被觀察者必須實現的職責，它必須能夠動態增加、取消觀察者。它一般是抽象類或是實現類，僅僅作爲被觀察者必須實現的職責：管理觀察者並通知觀察者

 

2.Observer觀察者

觀察者接收到消息後即進行更新操作，對收到的消息進行處理

 

3.ConcreteSubject具體的被觀察者

定義被觀察者自己的業務邏輯，同時定義對那些事件進行通知

 

4.ConcreteObserver具體的觀察者

每個觀察者在接收到消息後的處理邏輯是不同的，各個觀察者都有自己的處理邏輯

 

通用類圖代碼如下：

/**
 * 被觀察者
 * 
 */
public abstract class Subject {

    private List<Observer> list = new LinkedList<Observer>();

    // 添加一個觀察者
    public void attach(Observer o) {

        list.add(o);
    }

    // 刪除一個觀察者
    public void detach(Observer o) {

        list.remove(o);
    }

    // 通知觀察者
    public void notifyObserver() {

        for (Observer o : list) {
            o.update();
        }
    }
}

 

/**
 * 具體被觀察者
 * 
 */
public class ConcreteSubject extends Subject {

    public void doSomething() {
        // 通知觀察者
        super.notifyObserver();
    }
}

 

/**
 * 觀察者
 * 
 */
public interface Observer {

    public void update();
}

 

public class ConcreteObserver implements Observer {

    /**
     * 
     * @see com.huashao.chapter.chapter22.ch01.Observer#update()
     */
    @Override
    public void update() {

        System.out.println("收到消息.....");
    }

}

 

由於觀察者模式是一個經常使用的模式，所以JDK也對其做了抽象級的定義

 

/**
 * A class can implement the <code>Observer</code> interface when it
 * wants to be informed of changes in observable objects.
 *
 * @author  Chris Warth
 * @version 1.20, 11/17/05
 * @see     java.util.Observable
 * @since   JDK1.0
 */
public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}

 

public class Observable {
    private boolean changed = false;
    private Vector obs;
   
    /**創建被觀察者，並初始化觀察者容器 */

    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) {
	/*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        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();
    }

    /**
     * 
     *
     */
    protected synchronized void setChanged() {
	changed = true;
    }

    /**
     */
    protected synchronized void clearChanged() {
	changed = false;
    }

    /**
     */
    public synchronized boolean hasChanged() {
	return changed;
    }

    /**
     */
    public synchronized int countObservers() {
	return obs.size();
    }
}