当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

意图

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

主要解决

一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用

一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决

使用面向对象技术，可以将这种依赖关系弱化。

关键代码

在抽象类里有一个 ArrayList 存放观察者们。

应用实例

  1. 拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。

优点

  1. 观察者和被观察者是抽象耦合的。
  2. 建立一套触发机制。

缺点

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

使用场景

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

注意事项

1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

示例

分别有是三个观察者：二进制观察者、八进制观察者、十六进制观察者，当观察到有数字时会输出对应格式
image.png

  1. #include "stdafx.h"
  3. #include <iostream>
  4. #include <vector>
  5. #include <bitset>
  7. class Subject;
  9. // 观察者基类
  10. class Observer
  11. {
  13. public:
  14.     virtual void update() = 0;
  16. protected:
  17.     Subject* pSubject;
  18. };
  20. // 被观察者
  21. class Subject
  22. {
  23. public:
  24.     int GetState()
  25.     {
  26.         return state;
  27.     }
  29.     void SetState(int state)
  30.     {
  31.         this->state = state;
  32.         NotifyAllObservers();
  33.     }
  35.     void Attach(Observer* observer)
  36.     {
  37.         observers.push_back(observer);
  38.     }
  40.     void NotifyAllObservers(){
  41.         for (Observer* observer : observers)
  42.         {
  43.             observer->update();
  44.         }
  45.     }
  47. private:
  48.     std::vector<Observer*> observers;
  49.     int state;
  50. };
  52. // 二进制观察者
  53. class BinaryObserver : public Observer
  54. {
  55. public:
  56.     BinaryObserver(Subject* subject)
  57.     {
  58.         this->pSubject = subject;
  59.         this->pSubject->Attach(this);
  60.     }
  62.     virtual void update()
  63.     {
  64.         std::cout << "Binary String: " << std::bitset<8>(pSubject->GetState()) << std::endl;
  65.     }
  66. };
  68. // 八进制观察者
  69. class OctalObserver : public Observer
  70. {
  71. public:
  72.     OctalObserver(Subject* subject)
  73.     {
  74.         this->pSubject = subject;
  75.         this->pSubject->Attach(this);
  76.     }
  78.     virtual void update()
  79.     {
  80.         std::cout << "Octal String: " << std::oct << pSubject->GetState() << std::endl;
  81.     }
  82. };
  84. // 十六进制观察者
  85. class HexaObserver : public Observer
  86. {
  87. public:
  88.     HexaObserver(Subject* subject)
  89.     {
  90.         this->pSubject = subject;
  91.         this->pSubject->Attach(this);
  92.     }
  94.     virtual void update()
  95.     {
  96.         std::cout << "Hex String: " << std::hex << pSubject->GetState() << std::endl;
  97.     }
  98. };
  100. int main()
  101. {
  102.     Subject* pSubject = new Subject();
  104.     HexaObserver hexaObserver(pSubject);
  105.     OctalObserver octalObserver(pSubject);
  106.     BinaryObserver binaryObserver(pSubject);
  108.     std::cout << "First state change: 15" << std::endl;
  109.     pSubject->SetState(15);
  111.     std::cout << "Second state change: 10" << std::endl;
  112.     pSubject->SetState(10);
  113. }
First state change: 15
Hex String: f
Octal String: 17
Binary String: 00001111
Second state change: 10
Hex String: a
Octal String: 12
Binary String: 00001010