JAVA設計模式之觀察者模式

概念：

觀察者模式（observer），

主要用于1:N的通知。當一個對象（目标對象Subject或Objservable，消息釋出）的狀态變化時，它需要及時通知一系列對象（觀察者對象，Observer，消息訂閱），令他們做出響應。

通知觀察者的兩種方式：

1. 推

   每次都會把通知以廣播方式發送給所有觀察者，所有觀察者被動接受。

2. 拉

   觀察者隻要知道情況即可。至于什麼時候擷取内容，都由觀察者自主決定。

角色

目标對象Subject

具體目标對象ConcreteSubject

抽象觀察者接口Observer

具體觀察者ConcreteObserver

類圖

應用

1. 聊天室程式，伺服器發給用戶端
2. 郵件訂閱
3. Servlet中的監聽器實作
4. Android中的廣播機制
5. 群發消息
6. JDK的AWT中事件處理模型，基于觀察者模式的委派事件模型

代碼

// 目标對象
public class Subject {
    protected List observers = new ArrayList<>();

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

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    // 通知觀察者更新
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }

}
           

// 具體目标對象
public class ConcreteSubject extends Subject {
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        this.notifyAllObservers();
    }
}
           

// 觀察者接口
public interface Observer {

    void update(Subject subject);
}
           

// 具體觀察者
public class ObserverA implements Observer {

    private int myState;    //與subject保持同步

    @Override
    public void update(Subject subject) {
        myState = ((ConcreteSubject) subject).getState();
        System.out.println("update to " + myState);
    }

    public int getMyState() {
        return myState;
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }
}
           

// 用戶端
public class Main {
    public static void main(String[] args) {
        // 建立具體通知者
        ConcreteSubject subject = new ConcreteSubject();

        // 建立多個觀察者
        ObserverA observer1 = new ObserverA();
        ObserverA observer2 = new ObserverA();
        ObserverA observer3 = new ObserverA();

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
        subject.registerObserver(observer3);

        // 改變subject的狀态值
        subject.setState(1);

        System.out.println(observer1.getMyState());
        System.out.println(observer2.getMyState());
        System.out.println(observer3.getMyState());

    }
}
           

通過javase 的java.util.Observable, java.util.Observer實作

// 通過java.util.Observable實作目标對象
public class ConcreteSubject2 extends Observable {
    private int state;

    public void setState(int state) {
        this.state = state;
        setChanged();
        notifyObservers(state);
    }
}
           

// 通過java.util.Observer實作觀察者
public class Observer2 implements java.util.Observer {
    private int myState;

    @Override
    public void update(Observable o, Object arg) {
        myState = (int) arg;
    }

    public int getMyState() {
        return myState;
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }
}
           

// 通過javase 的java.util.Observable, java.util.Observer實作
public class Main2 {
    public static void main(String[] args) {
        ConcreteSubject2 subject2 = new ConcreteSubject2();

        Observer2 observer1 = new Observer2();
        Observer2 observer2 = new Observer2();
        Observer2 observer3 = new Observer2();

        subject2.addObserver(observer1);
        subject2.addObserver(observer2);
        subject2.addObserver(observer3);

        subject2.setState(10);

        System.out.println(observer1.getMyState());
        System.out.println(observer2.getMyState());
        System.out.println(observer3.getMyState());
    }
}