C++软件设计模式之观察者模式

观察者模式的动机意图

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，全部依赖于它的对象都能够主动收到通知并进行相应的更新。
动机意图：

• 解耦：观察者模式的动机在于解耦对象之间的关系。具体来说，它让一个对象（被观察者或主题）不必要知道具体有哪些对象（观察者）依赖于它，从而降低了对象之间的耦合度。
  
• 主动通知：当被观察者的状态发生变化时，全部观察者都会主动收到通知，并执行相应的操纵。这种机制使得体系更加灵活，易于扩展和维护。
  

适用场合

观察者模式适用于以下场景：

• 当一个对象的状态变化必要通知其他对象，而且你不知道这些对象的具体数量和类型时。例如，图形用户界面（GUI）中的按钮点击事件，可以通知多个监听器。
  
• 当必要在不修改被观察者代码的情况下，动态添加或删除观察者时。这种情况下，观察者模式可以实现松耦合的设计。
  
• 当一个对象的状态变化会影响多个其他对象，而且这些对象必要根据状态变化主动更新时。例如，股票价格的变化会影响多个投资者的计谋。
  

观察者模式的变体

观察者模式有几种常见的变体，具体取决于通知机制、更新方式以及观察者的管理方式。以下是几种常见的变体：

• 推模型（Push Model）：
  
  
  
  • 特点：被观察者主动将状态变化的信息推送给全部观察者。
    
  • 优点：观察者不必要知道被观察者的内部结构，只必要处理推送过来的数据。
    
  • 缺点：被观察者必要知道观察者的接口，可能会导致观察者和被观察者之间的耦合。
    
  
  
• 拉模型（Pull Model）：
  
  
  
  • 特点：被观察者仅通知观察者状态已发生变化，观察者必要主动去拉取被观察者的具体状态。
    
  • 优点：观察者可以只拉取自己感兴趣的部分状态，淘汰不必要的数据传输。
    
  • 缺点：观察者必要了解被观察者的内部结构。
    
  
  
• 事件机制（Event-based Model）：
  
  
  
  • 特点：被观察者通过事件通知观察者，观察者可以订阅特定类型的事件。
    
  • 优点：可以处理更复杂的事件类型，支持多种事件的订阅和处理。
    
  • 缺点：实现复杂度较高。
    
  
  
• 观察者队列（Observer Queue）：
  
  
  
  • 特点：使用队列来管理观察者，当被观察者状态变化时，将通知放入队列中，观察者从队列中取出通知进行处理。
    
  • 优点：可以实现异步通知，进步体系的并发性能。
    
  • 缺点：可能引入额外的复杂性和延迟。
    
  
  
• 弱引用观察者（Weak Reference Observer）：
  
  
  
  • 特点：使用弱引用（Weak Reference）来管理观察者，防止观察者对象未被开释时导致的内存泄漏。
    
  • 优点：可以避免内存泄漏题目。
    
  • 缺点：必要额外的机制来管理弱引用。
    
  
  

总结

观察者模式通过解耦对象之间的关系，提供了一种灵活且易于扩展的通知机制。它的变体如推模型、拉模型、事件机制等，使得它在差别的场景中可以有差别的实现方式。基于观察者模式的特点，发布-订阅模式、事件驱动架构、MVC模式等软件架构模式在现代软件开发中得到了广泛的应用。这些架构模式不但进步了体系的灵活性和可维护性，还使得体系在面对变化时能够更加从容应对。
下面是观察者模式的差别变体的C++代码示例，包罗推模型、拉模型、事件机制、观察者队列和弱引用观察者。
1. 推模型（Push Model）

在推模型中，被观察者将状态变化的信息主动推送给全部观察者。
示例代码

1. #include <iostream>
2. #include <vector>
3. #include <string>
5. // 观察者接口
6. class Observer {
7. public:
8.     virtual void update(const std::string& message) = 0;
9.     virtual ~Observer() = default;
10. };
12. // 具体观察者
13. class ConcreteObserver : public Observer {
14. public:
15.     void update(const std::string& message) override {
16.         std::cout << "Observer received message: " << message << std::endl;
17.     }
18. };
20. // 被观察者接口
21. class Subject {
22. public:
23.     virtual void attach(Observer* observer) = 0;
24.     virtual void detach(Observer* observer) = 0;
25.     virtual void notify(const std::string& message) = 0;
26.     virtual ~Subject() = default;
27. };
29. // 具体被观察者
30. class ConcreteSubject : public Subject {
31. private:
32.     std::vector<Observer*> observers;
34. public:
35.     void attach(Observer* observer) override {
36.         observers.push_back(observer);
37.     }
39.     void detach(Observer* observer) override {
40.         observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
41.     }
43.     void notify(const std::string& message) override {
44.         for (Observer* observer : observers) {
45.             observer->update(message);
46.         }
47.     }
49.     void changeState(const std::string& message) {
50.         std::cout << "Subject state changed. Notifying observers..." << std::endl;
51.         notify(message);
52.     }
53. };
55. int main() {
56.     ConcreteSubject subject;
57.     ConcreteObserver observer1;
58.     ConcreteObserver observer2;
60.     subject.attach(&observer1);
61.     subject.attach(&observer2);
63.     subject.changeState("Hello Observers!");
65.     subject.detach(&observer1);
67.     subject.changeState("Hello again!");
69.     return 0;
70. }

复制代码

2. 拉模型（Pull Model）

在拉模型中，被观察者仅通知观察者状态已发生变化，观察者必要主动去拉取被观察者的具体状态。
示例代码

1. #include <iostream>
2. #include <vector>
3. #include <string>
5. // 被观察者接口
6. class Subject {
7. public:
8.     virtual std::string getState() const = 0;
9.     virtual void notify() = 0;
10.     virtual void setState(const std::string& state) = 0;
11.     virtual void attach(class Observer* observer) = 0;
12.     virtual void detach(class Observer* observer) = 0;
13.     virtual ~Subject() = default;
14. };
16. // 具体被观察者
17. class ConcreteSubject : public Subject {
18. private:
19.     std::string state;
20.     std::vector<class Observer*> observers;
22. public:
23.     std::string getState() const override {
24.         return state;
25.     }
27.     void setState(const std::string& state) override {
28.         this->state = state;
29.         notify();
30.     }
32.     void attach(Observer* observer) override {
33.         observers.push_back(observer);
34.     }
36.     void detach(Observer* observer) override {
37.         observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
38.     }
40.     void notify() override {
41.         for (Observer* observer : observers) {
42.             observer->update();
43.         }
44.     }
45. };
47. // 观察者接口
48. class Observer {
49. protected:
50.     Subject* subject;
52. public:
53.     Observer(Subject* subject) : subject(subject) {}
54.     virtual void update() = 0;
55.     virtual ~Observer() = default;
56. };
58. // 具体观察者
59. class ConcreteObserver : public Observer {
60. public:
61.     ConcreteObserver(Subject* subject) : Observer(subject) {}
63.     void update() override {
64.         std::string state = subject->getState();
65.         std::cout << "Observer received state: " << state << std::endl;
66.     }
67. };
69. int main() {
70.     ConcreteSubject subject;
71.     ConcreteObserver observer1(&subject);
72.     ConcreteObserver observer2(&subject);
74.     subject.attach(&observer1);
75.     subject.attach(&observer2);
77.     subject.setState("State 1");
79.     subject.detach(&observer1);
81.     subject.setState("State 2");
83.     return 0;
84. }

复制代码

3. 事件机制（Event-based Model）

在事件机制中，被观察者通过事件通知观察者，观察者可以订阅特定类型的事件。
示例代码

1. #include <iostream>
2. #include <vector>
3. #include <string>
4. #include <map>
5. #include <functional>
7. // 事件类型
8. enum class EventType {
9.     StateChanged,
10.     DataUpdated
11. };
13. // 事件
14. class Event {
15. public:
16.     EventType type;
17.     std::string data;
19.     Event(EventType type, const std::string& data) : type(type), data(data) {}
20. };
22. // 观察者接口
23. class Observer {
24. public:
25.     virtual void handleEvent(const Event& event) = 0;
26.     virtual ~Observer() = default;
27. };
29. // 具体观察者
30. class ConcreteObserver : public Observer {
31. public:
32.     void handleEvent(const Event& event) override {
33.         std::cout << "Observer received event of type: " << static_cast<int>(event.type)
34.                   << " with data: " << event.data << std::endl;
35.     }
36. };
38. // 被观察者接口
39. class Subject {
40. private:
41.     std::map<EventType, std::vector<Observer*>> eventObservers;
43. public:
44.     void attach(EventType type, Observer* observer) {
45.         eventObservers[type].push_back(observer);
46.     }
48.     void detach(EventType type, Observer* observer) {
49.         auto& observers = eventObservers[type];
50.         observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
51.     }
53.     void notify(const Event& event) {
54.         auto& observers = eventObservers[event.type];
55.         for (Observer* observer : observers) {
56.             observer->handleEvent(event);
57.         }
58.     }
60.     void changeState(const std::string& state) {
61.         std::cout << "Subject state changed." << std::endl;
62.         notify(Event(EventType::StateChanged, state));
63.     }
65.     void updateData(const std::string& data) {
66.         std::cout << "Subject data updated." << std::endl;
67.         notify(Event(EventType::DataUpdated, data));
68.     }
69. };
71. int main() {
72.     Subject subject;
73.     ConcreteObserver observer1;
74.     ConcreteObserver observer2;
76.     subject.attach(EventType::StateChanged, &observer1);
77.     subject.attach(EventType::DataUpdated, &observer2);
79.     subject.changeState("New State");
80.     subject.updateData("New Data");
82.     subject.detach(EventType::StateChanged, &observer1);
84.     subject.changeState("Another State");
86.     return 0;
87. }

复制代码

4. 观察者队列（Observer Queue）

在观察者队列中，使用队列来管理观察者，当被观察者状态变化时，将通知放入队列中，观察者从队列中取出通知进行处理。
示例代码

1. #include <iostream>
2. #include <queue>
3. #include <string>
4. #include <mutex>
5. #include <thread>
6. #include <condition_variable>
8. // 通知类型
9. class Notification {
10. public:
11.     virtual void process() = 0;
12.     virtual ~Notification() = default;
13. };
15. // 具体通知
16. class ConcreteNotification : public Notification {
17. private:
18.     std::string message;
20. public:
21.     ConcreteNotification(const std::string& message) : message(message) {}
23.     void process() override {
24.         std::cout << "Processing notification: " << message << std::endl;
25.     }
26. };
28. // 观察者队列
29. class ObserverQueue {
30. private:
31.     std::queue<Notification*> queue;
32.     std::mutex mutex;
33.     std::condition_variable cv;
35. public:
36.     void enqueue(Notification* notification) {
37.         std::lock_guard<std::mutex> lock(mutex);
38.         queue.push(notification);
39.         cv.notify_one();
40.     }
42.     void processQueue() {
43.         while (true) {
44.             std::unique_lock<std::mutex> lock(mutex);
45.             cv.wait(lock, [this] { return !queue.empty(); });
46.             Notification* notification = queue.front();
47.             queue.pop();
48.             lock.unlock();
50.             notification->process();
51.             delete notification;
52.         }
53.     }
54. };
56. int main() {
57.     ObserverQueue queue;
59.     std::thread worker([&queue]() { queue.processQueue(); });
61.     queue.enqueue(new ConcreteNotification("Notification 1"));
62.     queue.enqueue(new ConcreteNotification("Notification 2"));
63.     queue.enqueue(new ConcreteNotification("Notification 3"));
65.     worker.join();
67.     return 0;
68. }

复制代码

5. 弱引用观察者（Weak Reference Observer）

在弱引用观察者中，使用弱引用（Weak Reference）来管理观察者，防止观察者对象未被开释时导致的内存泄漏。
示例代码

1. #include <iostream>
2. #include <vector>
3. #include <memory>
4. #include <string>
5. #include <functional>
7. // 观察者接口
8. class Observer {
9. public:
10.     virtual void update(const std::string& message) = 0;
11.     virtual ~Observer() = default;
12. };
14. // 具体观察者
15. class ConcreteObserver : public Observer {
16. public:
17.     void update(const std::string& message) override {
18.         std::cout << "Observer received message: " << message << std::endl;
19.     }
20. };
22. // 被观察者接口
23. class Subject {
24. public:
25.     virtual void attach(std::weak_ptr<Observer> observer) = 0;
26.     virtual void notify(const std::string& message) = 0;
27.     virtual ~Subject() = default;
28. };
30. // 具体被观察者
31. class ConcreteSubject : public Subject {
32. private:
33.     std::vector<std::weak_ptr<Observer>> observers;
35. public:
36.     void attach(std::weak_ptr<Observer> observer) override {
37.         observers.push_back(observer);
38.     }
40.     void notify(const std::string& message) override {
41.         observers.erase(std::remove_if(observers.begin(), observers.end(),
42.                                       [](const std::weak_ptr<Observer>& observer) {
43.                                           return observer.expired();
44.                                       }), observers.end());
46.         for (auto& observer : observers) {
47.             if (auto sharedObserver = observer.lock()) {
48.                 sharedObserver->update(message);
49.             }
50.         }
51.     }
53.     void changeState(const std::string& message) {
54.         std::cout << "Subject state changed. Notifying observers..." << std::endl;
55.         notify(message);
56.     }
57. };
59. int main() {
60.     ConcreteSubject subject;
62.     auto observer1 = std::make_shared<ConcreteObserver>();
63.     auto observer2 = std::make_shared<ConcreteObserver>();
65.     subject.attach(observer1);
66.     subject.attach(observer2);
68.     subject.changeState("Hello Observers!");
70.     observer1.reset(); // 释放 observer1
72.     subject.changeState("Hello again!");
74.     return 0;
75. }

复制代码

总结

以上是观察者模式的几种差别变体的C++代码示例。每种变体都有其适用的场景和优缺点，开发者可以根据具体的需求选择合适的实现方式。观察者模式的焦点思想是解耦对象之间的关系，并通过通知机制实现对象之间的通讯。

基于观察者模式特点的软件架构模式

观察者模式的特性使得它在许多软件架构中都有重要的应用，以下是几种基于观察者模式特点的软件架构模式：

• 发布-订阅模式（Publish-Subscribe Pattern）：
  
  
  
  • 特点：发布-订阅模式是观察者模式的一种扩展，它将消息的发送者（发布者）和接收者（订阅者）完全解耦。发布者不必要知道订阅者的存在，订阅者也不必要知道发布者的存在。
    
  • 应用：常见的应用场景包罗消息队列体系（如 Kafka、RabbitMQ）、事件驱动体系等。
    
  • 优点：体系组件之间的耦合度极低，适合构建分布式体系。
    
  
  
• 事件驱动架构（Event-Driven Architecture）：
  
  
  
  • 特点：事件驱动架构是一种基于事件的架构模式，体系中的组件通过事件进行通讯。事件的产生和处理通常基于观察者模式。
    
  • 应用：常见的应用场景包罗图形用户界面、分布式体系、微服务架构等。
    
  • 优点：体系组件可以异步处理事件，进步体系的可扩展性和响应性。
    
  
  
• 模型-视图-控制器（MVC）模式：
  
  
  
  • 特点：MVC模式将应用步伐分为三个部分：模型（Model）、视图（View）和控制器（Controller）。模型是观察者模式中的被观察者，视图是观察者。当模型的状态发生变化时，视图会主动更新。
    
  • 应用：常见的应用场景包罗Web应用步伐、桌面应用步伐等。
    
  • 优点：模型和视图之间的解耦，使得体系更易于维护和扩展。
    
  
  
• 观察者-被观察者链（Observer-Observable Chain）：
  
  
  
  • 特点：在这种架构中，观察者和被观察者可以形成一个链式结构，每个被观察者可以同时是观察者。
    
  • 应用：常见的应用场景包罗事件流传链、责任链模式等。
    
  • 优点：可以实现复杂的事件流传和处理机制。
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。