模式动机

为某些对象建立一种“通知依赖关系”，一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）自动的得到通知。（一对多关系）

伪代码实现1

  1. // MainForm.cpp
  2. // c++不推荐多继承，但推荐一个主继承，其他都是接口的形式
  3. class MainForm : public form, public IProgress
  4. {
  5.     TextBox* txtFilePath;
  6.     TextBox* txtFileNumber;
  8.     ProgressBar* progressBar;
  10.  public:
  11.      void Button1_Click() {
  12.         string filePath = txtFilePath->getText();
  13.         int number = atoi(txtFileNumber->getText().c_str());
  15.         FileSplitter splitter(filePath, number, this);
  17.         splitter.split();
  18.      }
  20.     virtual void DoProgress(float value) {
  21.         progressBar->setValue(value);
  22.     }
  24. };
  1. // FileSplitter.cpp
  3. class IProgress
  4. {
  5. public:
  6.     virtual void DoProgress(float value) = 0;
  7.     virtual ~IProgress() {}
  8. };
  10. class FileSplitter
  11. {
  12.     string m_filePath;
  13.     int m_fileNumber;
  15.     // ProgressBar* m_ProgressBar;         // 具体的通知控件
  16.     IProgress* m_iprogress;                // 抽象的通知机制
  17.  public:
  18.     FileSplitter(const string& filePath, int fileNumber):
  19.         m_filePath(filePath),
  20.         m_fileNumber(fileNumber),
  21.         m_iprogress(iprogress) {
  23.     }
  25.     void split() {
  26.         // 1.读取大文件
  28.         // 2.分批次向小文件中写入
  29.         for(int i = 0; i < m_fileNumber; i++) {
  30.             if(m_iprogress != nullptr) {
  31.                 float progressValue = m_fileNumber;
  32.                 progressValue = (i + 1) / ProgressValue;
  33.                 m_iprogress->DoProgress(progressValue);        // 更新进度
  34.             }
  35.         }
  36.     }
  37. };

伪代码实现2（支持多个观察者）

  1. // MainForm.cpp
  2. // c++不推荐多继承，但推荐一个主继承，其他都是接口的形式
  3. class MainForm : public form, public IProgress
  4. {
  5.     TextBox* txtFilePath;
  6.     TextBox* txtFileNumber;
  8.     ProgressBar* progressBar;
  10.  public:
  11.      void Button1_Click() {
  12.         string filePath = txtFilePath->getText();
  13.         int number = atoi(txtFileNumber->getText().c_str());
  15.         ConsoleNotifier cn;
  17.         FileSplitter splitter(filePath, number);
  19.         splitter.addIProgress(this);
  20.         splitter.addIProgress(&cn);
  22.         splitter.split();
  24.         splitter.removeIProgress(this);
  25.      }
  27.     virtual void DoProgress(float value) {
  28.         progressBar->setValue(value);
  29.     }
  30. };
  32. class ConsoleNotifier : public IProgress
  33. {
  34. public：
  35.     virtual void DoProgress(float value) {
  36.          cout << "...";
  37.     }
  38. }
  1. // FileSplitter.cpp
  3. class IProgress
  4. {
  5. public:
  6.     virtual void DoProgress(float value) = 0;
  7.     virtual ~IProgress() {}
  8. };
  10. class FileSplitter
  11. {
  12.     string m_filePath;
  13.     int m_fileNumber;
  15.     // ProgressBar* m_ProgressBar;         // 具体的通知控件
  16.     List<IProgress*> m_iprogressList;    // 抽象的通知机制 （重点）支持多个观察者
  17.  public:
  18.     FileSplitter(const string& filePath, int fileNumber):
  19.         m_filePath(filePath),
  20.         m_fileNumber(fileNumber){
  22.     }
  24.     void addIProgress(IProgress* iprogress) {
  25.         m_iprogressList.add(iprogress);
  26.     }
  28.     void removeIProgress(IProgress* iprogress) {
  29.         m_iprogressList.remove(iprogress);
  30.     }
  32.     void split() {
  33.         // 1.读取大文件
  35.         // 2.分批次向小文件中写入
  36.         for(int i = 0; i < m_fileNumber; i++) {
  37.             // ...
  38.             float progressValue = m_fileNumber;
  39.             progressValue = (i + 1) / ProgressValue;
  40.             onProgress(progressValue);
  42.         }
  43.     }
  45. protected:
  46.     // 在某些框架中，甚至设计为virtual,供子类去改写
  47.     void onProgress() {
  48.         List<IProgress*>::Iterator itor = m_iprogressList.begin();
  49.         while(itor != m_iprogressList.end())
  50.         {
  51.             m_iprogress->DoProgress(progressValue);        // 更新进度
  52.         }
  53.     }
  54. };

要点总结

  • 使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合
  • 目标发送通知使，无需指定观察者，通知会自动传播
  • 观察者自己决定是否需要订阅通知，目标对象那个对象此一无所知
  • Observer模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分