观察者模式

2020-12-20

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

动机：Observer模式中关键对象是目标和观察者，一个目标可以有任意数目的依赖它的观察者，一旦目标的状态发生变化，所有的观察者都得到通知。作为对于这个通知的相应，每个观察者都将查询目标以使其状态与目标状态同步。这种交互也成为发布-订阅。目标是通知的发布者。它发出通知的时候并不知道谁是它的观察者，可以有任意数目的观察者订阅并接受通知。

适用性：一个抽象模型有两个方面，其中一个方面依赖于另外一个方面；对一个对象的改变需要同时改变其他对象，但不知道有多少对象有待改变；一个对象必须通知其他对象，而它又不能假定其他对象是谁。

结构如下：

参与者：

Subject: 目标知道它的观察者；提供注册和删除观察者对象的接口

Observer:观察者具有自我更新状态的接口

ConcreteSubject : 将有关状态存入各个ConcreteOberver对象；当状态发生改变时通知各个观察者。

ConcreteObserver:维护ConcreteSubject对象的引用；存储有关状态；实现Observer的接口，使其自身状态于目标状态保持一致。

代码实现如下：

#include <iostream>
#include <string>
#include <functional>
#include <map>
class NonCopyable{
protected:
  NonCopyable() = default;
  virtual ~NonCopyable() = default;
  NonCopyable(const NonCopyable&) = delete; //ban copy constructor
  NonCopyable&operator=(const NonCopyable&) = delete; // ban copy assignment
};
template <typename Func>
class Subject : NonCopyable{ public:
  Subject(){}
  ~Subject(){}
  //register observer
  int Attach(Func&& f){
    return Assign(f);
  }
  int Attach(const Func& f){
    return Assign(f);
  }
  //remove observer
  void Detach(int k){
    _Observers.erase(k);
  }
  //notify all observer when the Subject has changed
  template<typename ...Args>
  void  Notify(Args&& ...args){
    for(auto& it : _Observers){
      it.second(std::forward<Args>(args)...);
    }
  }
private:
  template <typename F>
  int Assign(F&& f){
    int k = _observerId ++;
    _Observers.emplace(k,std::forward<F>(f));
    return k;
  }
  int _observerId = 0; // the No of observer
  std::map<int,Func> _Observers;
};
//
struct StA{
  int a,b;
  void print(int a,int b){std::cout << a << "," << b << std::endl;}
};
void print(int a,int b){std::cout << a << "," << b << std::endl;}
int main(int argc,char **argv)
{
  Subject<std::function<void(int,int)>> mySubject;
  //register observer
  auto key = mySubject.Attach(print);
  StA sta;
  auto lambdaKey = mySubject.Attach([&](int a,int b){sta.a = a;sta.b = b;}); //lambda
  //std::function
  std::function<void(int,int)> f = std::bind(&StA::print,&sta,std::placeholders::_1,std::placeholders::_2);
  mySubject.Attach(f);
  int a = 1,b = 2;
  mySubject.Notify(a,b);
  mySubject.Detach(lambdaKey);

  return 0;
}

在代码中以将观察者定义为函数，当有参数传入到mySubject中，mySubject的状态发生改变，然后mySubject通知它的所有观察者，更新这些观察者的状态。上面的代码是c++11的代码。下面的代码是设计模式中的代码：

class Subject;
//观察者
class Observer {
public:
  virtual ~Observer(){}
  virtual void Update() = 0;
protected:
  Observer() {}
};
//目标对象
class Subject {
public:
  virtual ~Subject(){}
  //注册观察者
  virtual void Attach(Observer *o){
    _Observers.emplace_back(o);
  }
  //移除观察者
  virtual void Detach(Observer* o){
    _Observers.remove(o);
  }
  //通知
  virtual void Notify(){
    for(auto o : _Observers){
      o->Update();
    }
  }
protected:
  Subject(){}
private:
  std::list<Observer *> _Observers;
};

这里简化了一些信息。