JAVA设计模式之观察者模式

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());
    }
}