Observer(观察者模式)

1. 意图

        定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

        在观察者模式中，有两类对象：被观察者（Subject）和观察者（Observer）。被观察者是一个具有状态的对象，当其状态发生变化时，会通知所有的观察者。观察者是一个依赖于被观察者的对象，它会接收到被观察者的通知，并进行相应的处理。

2. 适用性

        《GOF设计模式:可复用面向对象软件的基础》中描述如下：

• 当一个抽象模型有两方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们各自独立地自主改变和复用。
• 当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
• 当一个对象必须通知其它对象，而它又不能假定对象是谁。即对象之间关系是解耦合的。

3. 实现

#include <iostream>
#include <string>
#include <vector>class Observer {
public:virtual ~Observer() {}virtual void Update(const std::string &msg) = 0;
};class NetObserver : public Observer {
public:virtual void Update(const std::string &msg) override {std::cout << "NetObserver recv msg: " << msg << std::endl;}
};class SerialObserver : public Observer {
public:virtual void Update(const std::string &msg) override {std::cout << "SerialObserver recv msg: " << msg << std::endl;}
};class Subject {
public:virtual ~Subject() {}bool Attach(Observer *ptr) {if (ptr == nullptr)return false;m_vecObserver.push_back(ptr);return true;}void Detach(const Observer *ptr) {for (auto iter = m_vecObserver.begin(); iter != m_vecObserver.end();++iter) {if (*iter != ptr)continue;m_vecObserver.erase(iter);}}void Notify(const std::string &msg) {for (Observer *ptr : m_vecObserver)ptr->Update(msg);}private:std::vector<Observer *> m_vecObserver;
};class NetSubject : public Subject {
public:void DoSomething() { Notify("NetSubject msg"); }
};class SerialSubject : public Subject {
public:void DoSomething() { Notify("SerialSubject msg"); }
};void Test() {NetObserver *net1 = new NetObserver;NetObserver *net2 = new NetObserver;SerialObserver *serial1 = new SerialObserver;SerialObserver *serial2 = new SerialObserver;NetSubject *netSub = new NetSubject;SerialSubject *serialSub = new SerialSubject;netSub->Attach(net1);netSub->DoSomething();std::cout << "------------------------------" << std::endl;netSub->Attach(net2);netSub->DoSomething();std::cout << "------------------------------" << std::endl;serialSub->Attach(serial1);serialSub->DoSomething();std::cout << "------------------------------" << std::endl;serialSub->Attach(serial2);serialSub->DoSomething();delete net1;delete net2;delete serial1;delete serial2;delete netSub;delete serialSub;
}int main() {Test();return 0;
}

执行结果

NetObserver recv msg: NetSubject msg ------------------------------ NetObserver recv msg: NetSubject msg NetObserver recv msg: NetSubject msg ------------------------------ SerialObserver recv msg: SerialSubject msg ------------------------------ SerialObserver recv msg: SerialSubject msg SerialObserver recv msg: SerialSubject msg

4. 优缺点

• 松耦合性：被观察者和观察者之间是松耦合的，它们之间仅通过接口或抽象类进行通信，不需要直接相互引用，可以独立变化。

• 可扩展性：可以随时增加新的观察者，而不需要修改被观察者的代码，也可以很容易地添加新的被观察者。

• 可重用性：观察者模式可以在不同的场景中重复使用，不需要重写逻辑。

• 实时更新：被观察者一旦发生变化，所有的观察者都会实时收到通知并进行相应的更新，保证了数据的实时性。

• 观察者过多：如果观察者的数量过多，通知所有观察者可能会导致性能问题，影响系统的运行效率。

• 顺序控制困难：观察者之间是一种松散的耦合关系，无法控制观察者接收通知的顺序，可能会导致一些不可预测的问题。

• 循环依赖问题：如果观察者与被观察者之间存在循环依赖，可能会导致系统出现问题。

5. 模板实现

#include <functional>
#include <iostream>
#include <string>
#include <unordered_map>class ObserverA {
public:void UpdateA(const std::string &msg) {std::cout << "ObserverA msg: " << msg << std::endl;}
};class ObserverB {
public:void UpdateB(const std::string &msg) {std::cout << "ObserverB msg: " << msg << std::endl;}
};template <typename Func> class Event {
public:Event() : m_observeId(0) {}virtual ~Event() {}int Attach(Func &&f) { return Assign(f); }int Attach(const Func &f) { return Assign(f); }void Detach(int key) { m_mapOberserve.erase(key); }template <typename... Args> void Notify(Args &&...args) {for (auto &it : m_mapOberserve) {it.second(std::forward<Args>(args)...);}}private:Event(const Event &) = delete;Event &operator=(const Event &) = delete;template <typename F> int Assign(F &&f) {m_mapOberserve.emplace(m_observeId++, std::forward<F>(f));return m_observeId - 1;}private:int m_observeId;std::unordered_map<int, Func> m_mapOberserve;
};
void Test() {Event<std::function<void(const std::string &)>> event;ObserverA oba;int key =event.Attach(std::bind(&ObserverA::UpdateA, oba, std::placeholders::_1));event.Notify("AAAAA");std::cout << "-----------------------" << std::endl;ObserverB obb;event.Attach(std::bind(&ObserverB::UpdateB, obb, std::placeholders::_1));event.Notify("AAAAABBBBB");std::cout << "-----------------------" << std::endl;event.Detach(key);event.Notify("BBBBB");
}int main() {Test();return 0;
}

执行输出

ObserverA msg: AAAAA ----------------------- ObserverB msg: AAAAABBBBB ObserverA msg: AAAAABBBBB ----------------------- ObserverB msg: BBBBB