观察者模式 Observer

动机

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

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

模式定义

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

实例

实现进度条

朴素实现

class MainForm : public Form{
    TextBox * txtFilaPath;
    TextBox * txtFileNumber;

    ProgressBar *progressBar;
public :
    void Button_Click(){
        string filePath = txtFilaPath->getText();
        int number = atoi(txtFileNumber->getText());

        FileSplitter splitter(filePath,number,progressBar);

        splitter.split();
    }
}

class FileSpliter{
    string m_filePath;
    int m_fileNumber;
    ProgressBar *m_progressBar;
public:
    FileSpliter(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->setValue((i + 1) / m_fileNumber);
            }
        }
    }
}

观察者模式实现

class MainForm : public Form, public IProgress{
    TextBox * txtFilaPath;
    TextBox * txtFileNumber;

    ProgressBar *progressBar;
public :
    void Button_Click(){
        string filePath = txtFilaPath->getText();
        int number = atoi(txtFileNumber->getText());

        FileSplitter splitter(filePath,number);
        ConsoleNotifier cn;

        splitter.addIProgress(this);
        splitter.addIProgress(this);
        
        splitter.split(&cn);
    }
    virtual void Doprogress(float value){
        progressBar->setValue(value);
    }
}

class ConsoleNotifier : public IProgress{
public:
    virtual void DoProgress(float value){
        cout<<".";
    }
}

//抽象接口
class IProgress{
    string m_filePath;
public:
    virtual void DoProgress(float value) = 0;
    virtual ~IProgress(){};
}

class FileSpliter{
    string m_filePath;
    int m_fileNumber;
    // ProgressBar *m_progressBar; //通知控件
    vector<IProgress *> m_iprogressVector;   //抽象通知机制


public:
    FileSpliter(const string& filePath,int fileNumber):
    m_filePath(filePath),
    m_fileNumber(fileNumber){
    }
    void add_IProgress(IProgress *iprogress){
        m_iprogressVector.push_back(iprogress);
    }
    void remove_IProgress(IProgress *iprogress){
        m_iprogressVector.remove(iprogress);
    }
    void add
    void split(){
        //1.读取大文件

        //2.分批向小文件写入
        for(int i = 0;i < m_fileNumber;i ++){
            //..
            float progressValue = (i + 1) / m_fileNumber;
            onProgress(progressValue);
        }
    }
protected:
    void onProgress(float value){
        vector<IProgress *>::Iterator itor = m_iprogressVector.begin();

        while(itor != m_iprogressList.end()){
            (*itor)->DoProgress(value); //更新进度条
            itor ++;
        }
    }
}

结构图

要点总结

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

笔记

• 违背了依赖倒置原则 高层不能依赖底层 高层和底层都应该依赖于抽象 抽线不能依赖实现 实现应该依赖抽象
• 依赖：指的是编译时依赖 A依赖B B必须存在 A才能通过编译
• 独立一般指 你变我不变 松耦合