行为型设计模式_观察者模式

观察者模式

3.1. 模式动机

建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。

3.2. 模式定义

观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

观察者模式是一种对象行为型模式。

3.3. 模式结构

观察者模式包含如下角色：

Subject: 目标
ConcreteSubject: 具体目标
Observer: 观察者
ConcreteObserver: 具体观察者

3.4. 时序图

3.5代码分析

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>  // 用于 std::remove

// 观察者接口，定义了更新方法和获取状态的方法
class Observer {
public:
    virtual void update(int value) = 0;
    virtual int getState() const = 0;  // 获取当前状态
    virtual ~Observer() = default;
};

// 具体观察者类，实现了Observer接口
class ConcreteObserver : public Observer {
public:
    // 构造函数，初始化观察者的名称
    explicit ConcreteObserver(const std::string& name) : observerName(name), state(0) {}

    // 当被观察者的状态改变时，观察者会被通知并执行这个方法
    void update(int value) override {
        state = value;  // 更新观察者的状态
        std::cout << "Observer " << observerName << " notified with value: " << state << std::endl;
    }

    // 获取当前的状态值
    int getState() const override {
        return state;
    }

private:
    std::string observerName;  // 观察者的名称，用于区分不同的观察者
    int state;  // 存储当前的状态值
};

// 被观察者接口，定义了观察者管理和通知的方法
class Subject {
public:
    // 注册观察者
    virtual void attach(std::shared_ptr<Observer> observer) = 0;

    // 移除观察者
    virtual void detach(std::shared_ptr<Observer> observer) = 0;

    // 通知所有注册的观察者
    virtual void notify() = 0;

    virtual ~Subject() = default;
};

// 具体被观察者类，实现了Subject接口
class ConcreteSubject : public Subject {
public:
    // 将观察者添加到观察者列表中
    void attach(std::shared_ptr<Observer> observer) override {
        observers.push_back(observer);
    }

    // 从观察者列表中移除指定的观察者
    void detach(std::shared_ptr<Observer> observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    // 通知所有观察者，被观察者的状态已经改变
    void notify() override {
        for (const auto& observer : observers) {
            observer->update(state);  // 调用观察者的更新方法
        }
    }

    // 设置被观察者的状态，并通知所有观察者
    void setState(int value) {
        state = value;  // 更新状态
        notify();  // 通知所有观察者
    }

private:
    std::vector<std::shared_ptr<Observer>> observers;  // 观察者列表
    int state;  // 被观察者的状态
};

int main() {
    // 创建被观察者对象（ConcreteSubject实例）
    auto subject = std::make_shared<ConcreteSubject>();

    // 创建多个观察者对象，并将它们的名称传入构造函数
    auto observer1 = std::make_shared<ConcreteObserver>("Observer1");
    auto observer2 = std::make_shared<ConcreteObserver>("Observer2");
    auto observer3 = std::make_shared<ConcreteObserver>("Observer3");

    // 将观察者注册到被观察者中
    subject->attach(observer1);
    subject->attach(observer2);
    subject->attach(observer3);

    // 改变被观察者的状态，观察者将收到通知
    subject->setState(10);  // 这将通知所有已注册的观察者

    // 显示每个观察者当前的状态
    std::cout << "Observer1 state: " << observer1->getState() << std::endl;
    std::cout << "Observer2 state: " << observer2->getState() << std::endl;
    std::cout << "Observer3 state: " << observer3->getState() << std::endl;

    // 移除一个观察者，Observer2将不再接收通知
    subject->detach(observer2);

    // 再次改变状态，并通知剩下的观察者
    subject->setState(20);

    // 显示每个观察者当前的状态
    std::cout << "Observer1 state: " << observer1->getState() << std::endl;
    std::cout << "Observer3 state: " << observer3->getState() << std::endl;

    // Observer2的状态不会更新，因为它已被移除
    std::cout << "Observer2 state (should be unchanged): " << observer2->getState() << std::endl;

    return 0;
}

3.8. 优点

观察者模式的优点

观察者模式可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。
观察者模式在观察目标和观察者之间建立一个抽象的耦合。
观察者模式支持广播通信。
观察者模式符合“开闭原则”的要求。

3.9. 缺点

观察者模式的缺点

如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

3.10. 适用环境

在以下情况下可以使用观察者模式：

一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
一个对象必须通知其他对象，而并不知道这些对象是谁。
需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

3.11. 模式应用

观察者模式在软件开发中应用非常广泛，如某电子商务网站可以在执行发送操作后给用户多个发送商品打折信息，某团队战斗游戏中某队友牺牲将给所有成员提示等等，凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式。

3.12. 模式扩展

MVC模式

MVC模式是一种架构模式，它包含三个角色：模型(Model)，视图(View)和控制器(Controller)。观察者模式可以用来实现MVC模式，观察者模式中的观察目标就是MVC模式中的模型(Model)，而观察者就是MVC中的视图(View)，控制器(Controller)充当两者之间的中介者(Mediator)。当模型层的数据发生改变时，视图层将自动改变其显示内容。

3.13. 总结

观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅模式、模型-视图模式、源-监听器模式或从属者模式。观察者模式是一种对象行为型模式。
观察者模式包含四个角色：目标又称为主题，它是指被观察的对象；具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；观察者将对观察目标的改变做出反应；在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个目标对象，当这个目标对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新。
观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离，并在观察目标和观察者之间建立一个抽象的耦合，支持广播通信；其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间，而且如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
观察者模式适用情况包括：一个抽象模型有两个方面，其中一个方面依赖于另一个方面；一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变；一个对象必须通知其他对象，而并不知道这些对象是谁；需要在系统中创建一个触发链。
在JDK的java.util包中，提供了Observable类以及Observer接口，它们构成了Java语言对观察者模式的支持。