组件协作模式之观察者模式(Observer)

天大地大妈咪最大 提交于 2019-12-23 01:43:46

一、概念

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

二、动机

  在软件构建过程中,我们需要为某些对象建立一种“通知依赖关系”,一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密,将使得软件不能很好的抵御变化

  使用面向对象技术,可以将这种依赖关系弱化,并形成一种稳定的依赖关系,从而实现软件体系结构的松耦合。

三、源代码讲解

class MainForm : public Form {
    TextBox* txtFilePath;    //文件路径
    TextBox* txtFileNumber;    //希望分割的个数
    ProgressBar* progressBar;  //(变化)添加进度条控件,用来显示进度

public:
    void Button1_Click(){
        //收集到用户输入的参数信息
        string filePath = txtFilePath->getText();    
        int number = atoi(txtFileNumber->getText().c_str());
        //(变化)传递给FileSplitter,让该类去分割文件
        //将进度条传入文件分割类,在文件分割时改变进度条数据
        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++){
            //(变化)...
            float progressValue = m_fileNumber;  //设计数据,更新进度条
            progressValue = (i + 1) / progressValue;
            m_progressBar->setValue(progressValue);
        }
    }
};

  违背了第一个依赖倒置原则:高层模块不能依赖低层模块,二者都应该依赖抽象,抽象不能依赖实现细节,实现细节应该依赖抽象
在这里插入图片描述

四、使用观察者模式进行改进

// 抽象基类,设计一个进度通知接口类
class IProgress {
public:
    virtual void DoProgress(float value) = 0; // 0-1一个进度值
    virtual ~IProgress() { }
};

// 中层模块
class FileSplitter {
    string m_filePath;
    int m_fileNumber;
    List<IProgress*>  m_iprogressList; // 抽象通知机制,支持多个观察者,实现具体到抽象的跃迁
    // 上面实现了从紧耦合变为松耦合,FileSplitter没有再耦合一个具体细节(界面类)
public:
    FileSplitter(const string& filePath, int fileNumber) : 
                m_filePath(filePath), 
                m_fileNumber(fileNumber) {

                }

    void split() {
        // 1.读取大文件
        // 2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++) {
            // ...
            float progressValue = m_fileNumber;
            progressValue = (i + 1) / progressValue;
            onProgress(progressValue); // 向所有观察者发送通知
        }
    }

    void addIProgress(IProgress* iprogress) {
        m_iprogressList.push_back(iprogress); // 添加观察者
    }

    void removeIProgress(IProgress* iprogress) {
        m_iprogressList.remove(iprogress); // 移除观察者
    }
protected:
    virtual void onProgress(float value) {
        List<IProgress*>::iterator itor = m_iprogressList.begin();
        while (itor != m_iprogressList.end()) {
            (*itor)->DoProgress(value); // 更新进度条
            itor++;
        }
    }
};

// C++不推荐多继承,因为他会带来很多耦合性问题,但是支持一种,第一个是主继承,其他都是接口或者抽象基类
class MainForm : public Form, public IProgress {
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    // 这里面使用progressBar是没有关系的,他和MainForm本身是一体的,紧耦合的
    ProgressBar* progressBar;    
public:
    void Button1_Click() {
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        ConsoleNotifier cn;
        FileSplitter splitter(filePath, number);
        splitter.addIProgress(this); //订阅通知
        splitter.addIProgress(&cn)//订阅通知
        splitter.split();
        splitter.removeIProgress(this);
    }

    // 具体的通知机制
    virtual void DoProgress(float value) {
        // 主界面选择的GUI进度条,我们可以添加,也可以添加addIProgress(this)
        progressBar->setValue(value);    
    }
};

class ConsoleNotifier : public IProgress {
public:
    // 具体的通知机制
    virtual void DoProgress(float value) {
        cout << ".";
    }
};

在这里插入图片描述

五、类图结构

在这里插入图片描述

六、要点总结

  • 使用面向对象的抽象,Observer模式使得我们可以独立地改变目标与观察者,从而使二者之间的依赖关系达到松耦合。

  • 目标发送通知时,无需指定观察者,通知(可以携带通知信息作为参数)会自动传播

  • 观察者自己决定是否需要订阅通知,目标对象对此一无所知

  • Observer模式是基于事件的UI框架中非常常用(和Template一样常用)的设计模式,也是MVC模式中一个重要组成部分。

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!