GOF23设计模式之观察者模式

观察者模式

一、前置知识

广播机制的场景

场景

• 聊天室程序的创建。服务器创建好后，A,B,C三个客户端连上来公开聊 天。A向服务器发送数据，服务器端聊天数据改变。我们希望将这些聊 天数据分别发给其他在线的客户。也就是说，每个客户端需要更新服 务器端得数据。
• 网站上，很多人订阅了”java主题”的新闻。当有这个主题新闻时，就 会将这些新闻发给所有订阅的人。
• 大家一起玩CS游戏时，服务器需要将每个人的方位变化发给所有的客 户。

上面这些场景，我们都可以使用观察者模式来处理。我们 可以把多个订阅者、客户称之为观察者； 需要同步给多个订阅者的数据封装到对象中，称之为目标。

核心

观察者模式主要用于1∶N的通知。当一个对象（目标对象Subject 或Objservable）的状态变化时，他需要及时告知一系列对象（观察者对象，Observer），令他们做出响应。

通知观察者的方式

• 推
  • 每次都会把通知以广播方式发送给所有观察者，所有观察者只能被动接收。
• 拉
  • 观察者只要直到又情况即可。至于什么时候获取内容，获取什么内容，都可以自主决定。

UML类图

二、示例

1. Observer 观察者接口

public interface Observer {
    void  update(Subject subject);
}

2. Subject 目标接口对象

public class Subject {
    private List<Observer> list = new ArrayList<>();

    /**
     * 注册
     * @param obs
     */
    public void registerObserver(Observer obs){
        list.add(obs);
    }

    /**
     * 删除
     * @param obs
     */
    public void removeObserver(Observer obs){
        list.remove(obs);
    }

    /**
     * 通知所有观察者
     */
    public void notifyAllObserver(){
        for (Observer obj : list){
            obj.update(this);
        }
    }
}

3. 继承Subject接口，实现 ConcreteSubject

public class ConcreteSubject extends Subject{

    private int state;

    public int getState(){
        return state;
    }

    public void setState(int state){
        //修改变化
        this.state = state;
        //通知所有观察者
        this.notifyAllObserver();
    }
}

4. ObserverA 实现 Observer 接口

public class ObserverA implements Observer{

    private int myState;   //myState需要跟目标对象的state值保持一致！

    @Override
    public void update(Subject subject) {
        //进行强转赋值
        myState = ((ConcreteSubject) subject).getState();
    }

    public int getMyState(){
        return myState;
    }

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

5. 测试类

public class Client {
    public static void main(String[] args) {
        //目标对象
        ConcreteSubject subject = new ConcreteSubject();
        //创建多个观察者
        ObserverA obs1 = new ObserverA();
        ObserverA obs2 = new ObserverA();
        ObserverA obs3 = new ObserverA();

        //让这三个观察者，加入subject 队列中
        subject.registerObserver(obs1);
        subject.registerObserver(obs2);
        subject.registerObserver(obs3);

        subject.setState(3000);

        System.out.println("#########################");

        System.out.println(obs1.getMyState());
        System.out.println(obs2.getMyState());
        System.out.println(obs3.getMyState());

    }
}

运行截图

JAVASE提供了java.util.Observable和java.util.Observer来实现观察者模式

1. ConcreteSubject 继承 Observable

import java.util.Observable;

public class ConcreteSubject extends Observable {

    private int state;

    public void set(int state) {
        this.state = state;
        //表示目标对象已经做了更改
        setChanged();
        //通知所有的观察者
        notifyObservers(state);
    }

    public int getState() {
        return state;
    }

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

2. ObserverA 实现 Observer 接口 的update 的方法

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

public class ObserverA implements Observer {
    private int myState;

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

    public int getMyState() {
        return myState;
    }

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

3. Client 客户端类

public class Client {
    public static void main(String[] args) {
        //创建目标对象Obserable
        ConcreteSubject subject = new ConcreteSubject();

        //创建观察者
        ObserverA obs1 = new ObserverA();
        ObserverA obs2 = new ObserverA();
        ObserverA obs3 = new ObserverA();

        //将上面三个观察者对象添加到目标对象subject的观察者容器中
        subject.addObserver(obs1);
        subject.addObserver(obs2);
        subject.addObserver(obs3);

        //改变subject对象的状态
        subject.set(3000);
        System.out.println("===============状态修改了！");
        //观察者的状态发生了变化
        System.out.println(obs1.getMyState());
        System.out.println(obs2.getMyState());
        System.out.println(obs3.getMyState());

        subject.set(600);
        System.out.println("===============状态修改了！");
        //观察者的状态发生了变化
        System.out.println(obs1.getMyState());
        System.out.println(obs2.getMyState());
        System.out.println(obs3.getMyState());
    }
}

运行结果

三、总结

开发中常见的场景

• 聊天室程序的，服务器转发给所有客户端
• 网络游戏(多人联机对战)场景中，服务器将客户端的状态进行分发
• 邮件订阅
• Servlet中，监听器的实现
• Android中，广播机制
• JDK的AWT中事件处理模型,基于观察者模式的委派事件模型(Delegation Event Model)
  • 事件源----------------目标对象
  • 事件监听器------------观察者
• 京东商城中，群发某商品打折信息