设计模式[15]-观察者模式-Observer Pattern

1.观察者模式简介

观察者模式(Observer Pattern)是行为型(Behavioral)设计模式，定义了对象之间一对多的依赖关系，当一个对象发生状态变更，所有的依赖对象都会被通知。在观察者模式中，发生变化的对象就是观察目标，被通知的对象就是观察者，观察目标和观察者是一对多的关系。

观察者模式又被称作发布/订阅（Pub/Sub）模式。

观察者模式一共有四种角色：

(1) Subject（主题）：是观察的目标，可以是接口或者抽象类，定义了增加、移除、通知观察者的方法，还有自身操作的方法。

(2) ConcreteSubject（具体主题）：具体主题是Subject的子类，内部维护者具体有哪些观察者；当它的状态发生改变时，向它的各个观察者发出通知。有时候，Subject可以和ConcreteSubject合并成一个类。

(3)Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法。

(4)ConcreteObserver（具体观察者）：具体观察者实现抽象观察者定义的方法，完成具体的更新数据的动作。

2. 观察者模式举例

下面举个例子，当股票股价小于10元或者大约20元时，向关注股票的股民（Investor）发送通知消息。

序号	类名	角色	说明
1	Observer	Observer	抽象观察者
2	Investor	ConcreteSubject	股民类，具体观察者角色
3	Subject	Subject	抽象主题，是被观察的对象
4	Stock	ConcreteObserver	股票类，具体主题角色
5	ObserverMain	客户端	演示调用

Paste_Image.png

1. 抽象观察者

/**
 * 抽象观察者
 */
public interface Observer {

    void update(String message);
}

2. 股民类，具体观察者角色

/**
 * 股民类，具体观察者角色
 */
public class Investor implements Observer {

    private String name;

    public Investor(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println("股民[" + name + "]收到了消息：" + message);
    }
}

3.抽象主题，是被观察的对象。

/**
 * 抽象主题，是被观察的对象。
 */
public interface Subject {

    /**
     * 增加观察者
     *
     * @param observer
     */
    void addObserver(Observer observer);

    /**
     * 删除观察者
     *
     * @param observer
     */
    void deleteObserver(Observer observer);

    /**
     * 通知观察者
     *
     * @param message 消息
     */
    void notifyObservers(String message);

    /**
     * 模拟股票价格监控
     *
     * @param price 股票价格
     */
    void change(int price);

}

4.股票类，具体主题角色

/**
 * 股票类，具体主题角色
 */
public class Stock implements Subject {

    private Vector observers = new Vector<>();

    /**
     * 模拟股票价格监控
     *
     * @param price 股票价格
     */
    public void change(int price) {
        if (price > 2000) {
            notifyObservers("股票价格已经超过20元。");
        } else if (price < 1000) {
            notifyObservers("股票价格已经低于10元。");
        }
    }

    /**
     * 增加观察者
     *
     * @param observer
     */
    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    /**
     * 删除观察者
     *
     * @param observer
     */
    @Override
    public void deleteObserver(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 通知观察者
     *
     * @param message 消息
     */
    @Override
    public void notifyObservers(String message) {
        Enumeration enumeration = observers.elements();
        while (enumeration.hasMoreElements()) {
            Observer observer = enumeration.nextElement();
            observer.update(message);
        }
    }
}

5.调用演示

public static void main(String[] args) {
    // 创建观察者对象
    Observer observer1 = new Investor("张三");
    Observer observer2 = new Investor("李四");
    // 注册观察者对象
    Subject stock = new Stock();
    stock.addObserver(observer1);
    stock.addObserver(observer2);
    // stock 主题发生的变化，观察者收到通知
    stock.change(2100);
    stock.change(900);
}

结果输出：

股民[张三]收到了消息：股票价格已经超过20元。
股民[李四]收到了消息：股票价格已经超过20元。
股民[张三]收到了消息：股票价格已经低于10元。
股民[李四]收到了消息：股票价格已经低于10元。

3. 总结

观察者模式是一个使用频率很高的设计模式，为对象之间的行为联动提供了一套方案，简化了一对多的系统设计难度；需要注意的是，我们应该避免观察者和观察目标之间循环依赖。

有的同学曾经讨论观察者模式和“发布/订阅”模式之间的区别，提出一种观点：在观察者模式中，观察目标（本例中的Subject、Stock）直接依赖观察者（本例中的Observer）；而“发布/订阅”模式中，观察目标并不直接依赖于观察者，而是通过中介媒介来通信。

在消息队列中间件或者说JMS协议中，Topic就是“发布/订阅”的模式，发布消息的生产者把消息送入Topic，消费消息的消费者订阅这个Topic，从中消费数据；生产者和消费者互不依赖。

（完）