觀察者模式定義了一系列對象之間的一對多關系。當一個對象改變狀態(tài)， 其他依賴者都會收到通知。 -《HeadFisrt設計模式》

1. 舉個例子

/* 觀察的主題 */

public class Subject {

    private List<Observer> observers;

    public void init() {
        observers = new ArrayList<Observer>();
        observers.add(new Observer1());
        observers.add(new Observer2());
        observers.add(new Observer3());
    }

    public void somethingChanged() {
        for (Observer observer : observers) {
            observer.react();
        }
    }

    public static void main(String[] args) {
        Subject subject = new Subject();
        subject.init();
        subject.somethingChanged();
    }
}

/* 觀察者 */

public interface Observer {

    void react();
}

public class Observer1 implements Observer {

    public void react() {
        System.out.println("Observer1 receive message from subject.");
    }
}

public class Observer2 implements Observer {

    public void react() {
        System.out.println("Observer2 receive message from subject.");
    }
}

public class Observer3 implements Observer {

    public void react() {
        System.out.println("Observer3 receive message from subject.");
    }
}

2. 開閉原則

上面的代碼并不是真正觀察者模式，因為違反了面向對象設計中最基礎的設計原則。

軟件實體（類，模塊，方法等等）應當對擴展開放，對修改關閉，即軟件實體應當在不修改的前提下擴展。 - 開閉原則（Open-Close Principle）

每新增一個觀察者就需要在Subject類中調用一次observers.add，并不是對修改關閉。

3. 真正的觀察者模式

/* 觀察的主題 */

public class Subject {

    private List<Observer> observers;

    public void init() {
        observers = new ArrayList<Observer>();
    }

    public void somethingChanged() {
        for (Observer observer : observers) {
            observer.react();
        }
    }

    public void register(Observer observer) {
        observers.add(observer);
    }

    public static void main(String[] args) {
        Subject subject = new Subject();
        subject.init();

        Observer observer1 = new Observer1();
        observer1.listen(subject);

        Observer observer2 = new Observer1();
        observer2.listen(subject);

        Observer observer3 = new Observer1();
        observer3.listen(subject);

        subject.somethingChanged();
    }
}

/* 觀察者 */

public interface Observer {

    void react();

    void listen(Subject subject);
}

public class Observer1 implements Observer {

    public void react() {
        System.out.println("Observer1 receive message from subject.");
    }

    public void listen(Subject subject) {
        subject.register(this);
    }
}

public class Observer2 implements Observer {

    public void react() {
        System.out.println("Observer2 receive message from subject.");
    }

    public void listen(Subject subject) {
        subject.register(this);
    }
}

public class Observer3 implements Observer {

    public void react() {
        System.out.println("Observer3 receive message from subject.");
    }

    public void listen(Subject subject) {
        subject.register(this);
    }
}

4. JDK自帶的觀察者

/* 觀察的主題 */

import java.util.Observable;

public class Subject extends Observable {

    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer1 observer1 = new Observer1();
        subject.addObserver(observer1);

        Observer2 observer2 = new Observer2();
        subject.addObserver(observer2);

        Observer3 observer3 = new Observer3();
        subject.addObserver(observer3);

        subject.setChanged();
        subject.notifyObservers();
    }
}

/* 觀察者 */

import java.util.Observable;
import java.util.Observer;

public class Observer1 implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("Observer1 receive message from subject.");
    }
}

public class Observer2 implements Observer {

    public void react() {
        System.out.println("Observer2 receive message from subject.");
    }
}

public class Observer3 implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("Observer3 receive message from subject.");
    }
}

5. 注意事項

1. JDK中的被觀察對象在獲取觀察者時是同步的，但是執(zhí)行通知事件時卻不是。

package java.util;

public class Observable {

    public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

}

2. 如果順序執(zhí)行通知，某一觀察者錯誤會導致系統(tǒng)卡殼，一般采用異步方式。