什麼是觀察者模式(Observer)?

世界上並沒有完美的程序，但是我們並不因此而沮喪，因爲寫程序就是一個不斷追求完美的過程。

1. 意圖
   在我看來就是一個事件通知機制，一個對象的狀態發生變化，會通過觀察者告訴給其他對象
2. 類圖
   
3. 實例

// 觀察者
interface SimpleObserver{
    void update(SimpleObservable simpleObservable, Object arg);
}
// 被觀察者
abstract class SimpleObservable{
    // 狀態標誌
    private volatile boolean changed = false; // 增加volatile修飾符，保證多線程可見性
    protected synchronized void setChanged(){
        changed = true;
    }
    public synchronized boolean hasChanged(){
        return changed;
    }
    protected synchronized void clearChanged(){
        changed = false;
    }

    // 觀察者列表
    private Vector<SimpleObserver> observerVector;
    public SimpleObservable(){
        observerVector = new Vector<>();
    }
    public synchronized void addObserver(SimpleObserver simpleObserver){
        if(null == simpleObserver){
            throw new NullPointerException();
        }else if(!observerVector.contains(simpleObserver)){
            observerVector.addElement(simpleObserver);
        }
    }
    public synchronized void deleteObserver(SimpleObserver simpleObserver){
        observerVector.removeElement(simpleObserver);
    }
    public synchronized void deleteObservers(){
        observerVector.removeAllElements();
    }
    // 注意，狀態的改變需要加sync，但是遍歷observer.update不需要
    public void notifyObservers(Object arg){
        synchronized (this){
            if(!changed) return;
            clearChanged();
        }
        observerVector.forEach(observer -> observer.update(this, arg));
    }
    public void notifyObservers(){
        notifyObservers(null);
    }
    public synchronized int countObservers(){
        return observerVector.size();
    }
}

class MySimpleObservable extends SimpleObservable{
    private int state;
    public void setState(int state){
        this.state = state;
        this.setChanged(); // 狀態發生變化，狀態標誌位改爲true
        this.notifyObservers(state); // 通知觀察者
    }
    public int getState() {
        return state;
    }
}

class MySimpleObserver1 implements SimpleObserver{
    private Client1 client;
    public MySimpleObserver1(Client1 client){
        this.client = client;
    }

    @Override
    public void update(SimpleObservable simpleObservable, Object arg) {
        client.plus((int)arg);
    }
}

class MySimpleObserver2 implements SimpleObserver{
    private Client2 client;
    public MySimpleObserver2(Client2 client){
        this.client = client;
    }

    @Override
    public void update(SimpleObservable simpleObservable, Object arg) {
        client.multiply((int)arg);
    }
}

class Client1{
    public void plus(int arg){
        System.out.println("client1::plus "+ (20+arg));
    }
}

class Client2{
    public void multiply(int arg){
        System.out.println("client2::multiply "+ (3*arg));
    }
}

5. 測試

class testObserver{
    public static void main(String[] args) {
        // 創建client的觀察者
        MySimpleObserver1 mySimpleObserver1 = new MySimpleObserver1(new Client1());
        MySimpleObserver2 mySimpleObserver2 = new MySimpleObserver2(new Client2());
        // 創建被觀察者，併爲其添加觀察者
        MySimpleObservable mySimpleObservable = new MySimpleObservable();
        mySimpleObservable.addObserver(mySimpleObserver1);
        mySimpleObservable.addObserver(mySimpleObserver2);
        // 被觀察者狀態改變，觀察者通知客戶端
        System.out.println("observers count: "+ mySimpleObservable.countObservers());
        System.out.println("state changed to "+ 1+ ":");
        mySimpleObservable.setState(1);
        System.out.println("state changed to "+ 2+ ":");
        mySimpleObservable.setState(2);
    }
}

運行結果：

observers count: 2
state changed to 1:
client1::plus 21
client2::multiply 3
state changed to 2:
client1::plus 22
client2::multiply 6

想看更多嗎？請訪問：設計模式