观察者模式 (Observer)

观察者模式 是一种行为型设计模式，它定义了一种一对多的依赖关系，使得当一个对象的状态发生改变时，其依赖者（观察者）会收到通知并自动更新。

---

意图

• 定义对象之间的一对多依赖关系。
• 当一个对象状态发生变化时，通知所有依赖于它的对象。

---

使用场景

1. 事件驱动系统：

   • 如 GUI 程序中的按钮点击事件，按钮通知所有监听器。

2. 数据变化通知：

   • 数据模型的变化需要通知多个视图更新。

3. 解耦对象之间的依赖：

   • 被观察者与观察者通过接口交互，降低了耦合性。

---

参与者角色

1. 主题 (Subject)

   • 被观察者，维护观察者列表，并在状态发生变化时通知所有观察者。

2. 观察者 (Observer)

   • 定义了一个接口，用于接收通知并更新状态。

3. 具体主题 (ConcreteSubject)

   • 实现具体的主题逻辑，存储状态，并在状态改变时通知观察者。

4. 具体观察者 (ConcreteObserver)

   • 实现具体的观察者逻辑，接收通知并更新状态。

---

示例代码

以下代码展示了观察者模式的实现，使用 C++ 的现代特性（如 std::function、std::vector、shared_ptr）。

#include <iostream>
#include <vector>
#include <memory>
#include <functional>
#include <string>// 观察者接口
class Observer {
public:virtual ~Observer() = default;virtual void update(const std::string& message) = 0; // 接收通知
};// 具体观察者：实现观察者接口
class ConcreteObserver : public Observer {
private:std::string name; // 观察者名称，用于标识public:explicit ConcreteObserver(const std::string& observerName) : name(observerName) {}void update(const std::string& message) override {std::cout << "观察者 [" << name << "] 收到通知: " << message << std::endl;}
};// 被观察者接口
class Subject {
public:virtual ~Subject() = default;virtual void attach(std::shared_ptr<Observer> observer) = 0; // 添加观察者virtual void detach(std::shared_ptr<Observer> observer) = 0; // 移除观察者virtual void notify() = 0;                                   // 通知观察者
};// 具体被观察者：实现被观察者接口
class ConcreteSubject : public Subject {
private:std::vector<std::shared_ptr<Observer>> observers; // 存储观察者的列表std::string state;                                // 被观察者的状态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 setState(const std::string& newState) {state = newState;notify(); // 状态改变时通知所有观察者}void notify() override {for (const auto& observer : observers) {observer->update(state);}}
};// 客户端代码
int main() {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);// 修改被观察者的状态，通知观察者std::cout << "修改状态为: 状态A" << std::endl;subject->setState("状态A");// 移除一个观察者subject->detach(observer2);std::cout << "修改状态为: 状态B" << std::endl;subject->setState("状态B");return 0;
}

---

代码解析

1. 观察者接口 (Observer)

• 定义了一个 update 方法，用于接收通知：

class Observer {
public:virtual ~Observer() = default;virtual void update(const std::string& message) = 0; // 接收通知
};

2. 具体观察者 (ConcreteObserver)

• 实现了 Observer 接口，并通过 update 方法更新状态：

class ConcreteObserver : public Observer {
private:std::string name;public:explicit ConcreteObserver(const std::string& observerName) : name(observerName) {}void update(const std::string& message) override {std::cout << "观察者 [" << name << "] 收到通知: " << message << std::endl;}
};

3. 被观察者接口 (Subject)

• 定义了添加、移除观察者的方法，以及通知观察者的 notify 方法：

class Subject {
public:virtual ~Subject() = default;virtual void attach(std::shared_ptr<Observer> observer) = 0;virtual void detach(std::shared_ptr<Observer> observer) = 0;virtual void notify() = 0;
};

4. 具体被观察者 (ConcreteSubject)

• 存储观察者列表，并在状态改变时通知观察者：

class ConcreteSubject : public Subject {
private:std::vector<std::shared_ptr<Observer>> observers;std::string state;public:void setState(const std::string& newState) {state = newState;notify(); // 状态改变时通知所有观察者}void notify() override {for (const auto& observer : observers) {observer->update(state);}}
};

5. 客户端

• 客户端通过 attach 方法订阅观察者，并通过 setState 方法触发通知：

auto subject = std::make_shared<ConcreteSubject>();
auto observer1 = std::make_shared<ConcreteObserver>("Observer1");
subject->attach(observer1);
subject->setState("状态A");

---

优缺点

优点

1. 解耦：
   • 被观察者与观察者之间通过接口交互，降低了依赖性。
2. 扩展性强：
   • 可以轻松增加新的观察者，而无需修改被观察者代码。
3. 动态通知：
   • 可以在运行时动态添加或移除观察者。

缺点

1. 通知开销：
   • 当观察者较多时，通知的开销可能较大。
2. 复杂性增加：
   • 系统中对象关系变得复杂，可能导致调试困难。

---

适用场景

1. 事件驱动系统：

   • 如 GUI 程序、游戏引擎等。

2. 模型-视图结构：

   • 数据模型的变化通知视图更新。

3. 分布式系统：

   • 如多个服务监听同一个事件源。

---

总结

观察者模式通过定义一对多的依赖关系，解决了对象之间的动态联动问题，是事件驱动系统中非常重要的设计模式。