Observer观察者模式_观察者observer-CSDN博客

本文链接：https://blog.csdn.net/zhaopengvv/article/details/124077727

1. 动机

在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” ——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。
使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

以一个文件分割器为例，主窗口点击文件分割按钮，可以将一个文件分割为多个。另外，在分割的过程中需要展示分割的进度。

class MainForm : public Form {
private:
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar; // 进度条 通知控件
public:
    void ButtonClick()
    {
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        FileSplitter splitter(filePath, number, progressBar);
        splitter.split();
    }
};

class FileSplitter {
    string m_filePath;
    int m_fileNumber;
    ProgressBar* m_progressBar; // 进度条
public:
    FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :
        m_filePath(filePath), m_fileNumber(fileNumber), m_progressBar(progressBar)
    {}
    void split()
    {
        // 1. 读取文件大小
        
        // 2. 分批次向小文件中写入
        for (int i= 0; i < m_fileNumber; i++) {
            //...
            if (m_progressBar != nullptr) {
                m_progressBar.setVal((i + 1) / m_fileNumber); // 更新进度条
            }
        }
    }
};

上述例子违反了依赖倒置设计原则。
依赖关系：是一种编译依赖关系，例如A依赖于B，A编译的过程中必须有B存在才能编译通过。
依赖倒置原则：高层模块不能依赖低层模块，二者都应该依赖于抽象；抽象不能依赖实现实现细节，实现细节应该依赖抽象。
FileSplitter类耦合了具体的实现细节ProgressBar（进度条），ProgressBar是一种具体的通知机制。

2. 观察者模式定义

定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。——《设计模式》GoF

3. 观察者模式结构

在这里插入图片描述

4. 观察者模式实现

class IProgress {
public:
    virtual void DoProgress(float value) = 0;
    virtual ~IProgress(){};
};

class MainForm : public Form : public IProgress{
private:
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar; // 通知

public:
    void ButtonClick()
    {
        
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        FileSplitter splitter(filePath, number, this);
        splitter.split();
    }
    // 实现接口
    virtual void DoProgress(float value)
    {
        progressBar->SetVal(value);
    }
};

class FileSplitter {
    string m_filePath;
    int m_fileNumber;
    // ProgressBar* m_progressBar; // 具体通知控件 紧耦合
    IProgress* m_iprogress; // 抽象通知机制 松耦合,不依赖MainForm

public:
    FileSplitter(const string& filePath, int fileNumber, IProgress* iprogress) :
        m_filePath(filePath),
        m_fileNumber(fileNumber),
        m_iprogress(iprogress)
    {}
    void split()
    {
        // 1. 读取文件大小

        // 2. 分批次向小文件中写入
        for (int i= 0; i < m_fileNumber; i++) {
            //...

            float progressVal = m_fileNumber;
            progressVal = (i + 1) / progressVal
            OnProgress(progressVal);
        }
    }
protected:
    void OnProgress(float value)
    {
        if (m_iprogress != nullptr) {
            m_iprogress->DoProgress(value);
        }
    }

};

将FileSplitter类中的成员变量ProgressBar* progressBar紧耦合结构，改变为IProgress* m_iprogress松耦合结构。FileSplitter类没有耦合任何一个界面类，可以进行独立的编译，符合依赖倒置原则。

上述demo仅有一个观察者，下面demo可以支持多个观察者。

//  多个观察者
class IProgress {
public:
    virtual void DoProgress(float value) = 0;
    virtual ~IProgress(){};
};

class MainForm : public Form : public IProgress{
public:
    void ButtonClick()
    {
        ConsoleNotifier cn;
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        ConsoleNotifier cn;
        FileSplitter splitter(filePath, number);
        splitter.AddIProgress(this); // 添加windows进度条通知
        splitter.AddIProgress(&cn);	// 添加Console进度通知
        splitter.split();
    }
    // 实现接口
    virtual void DoProgress(float value)
    {
        progressBar->SetVal(value);
    }

private:
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar; // 通知
};
// Console进度通知方式
class ConsoleNotifier : public IProgress {
public:
    // 实现接口
    virtual void DoProgress(float value)
    {
         cout << "." << endl;
    }
};

class FileSplitter {
public:
    FileSplitter(const string& filePath, int fileNumber) :
        m_filePath(filePath),
        m_fileNumber(fileNumber),
    {}
    void AddIProgress(IProgress* progressBar)
    {
        m_progressBarList.add(progressBar)
    }
    void RemoveIProgress(IProgress* progressBar)
    {
        m_progressBarList.remove(progressBar)
    }
    void split()
    {
        // 1. 读取文件大小

        // 2. 分批次向小文件中写入
        for (int i= 0; i < m_fileNumber; i++) {
            //...

            float progressVal = m_fileNumber;
            progressVal = (i + 1) / progressVal
            OnProgress(progressVal);
        }
    }
protected:
    void OnProgress(float value)
    {
        List<IProgress*>::Iterator itor = m_progressBarList.begin();
        while (itor != m_progressBarList.end()) {
            (itor*)->DoProgress(value);
            itor++;
        }
    }

private:
    string m_filePath;
    int m_fileNumber;
    // ProgressBar* m_progressBar; // 具体通知控件 紧耦合
    List<IProgress*> m_progressBarList;
};