设计模式---组件协作模式之观察者模式(Observer)
一:概念
Observer模式的作用是当一个对象的状态发生变化时,能够自动通知其他关联对象,自动刷新对象状态
Observer模式提供给关联对象一种同步通信的手段,使得某个对象与依赖他的其他对象之间保持状态同步
二:动机
在软件构建过程中,我们需要为某些对象建立一种“通知依赖关系”----一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密,将使得软件不能很好的抵御变化。
使用面向对象技术,可以将这种依赖关系弱化,并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合
三:代码解析(文件分割器)
(一)结构化思想
1.原代码
主窗口界面
class MainForm : public Form { TextBox* txtFilePath; //文件路径 TextBox* txtFileNumber; //希望分割的个数public: void Button1_Click(){ //收集到用户输入的参数信息 string filePath = txtFilePath->getText(); int number = atoi(txtFileNumber->getText().c_str()); //传递给FileSplitter,让该类去分割文件 FileSplitter splitter(filePath, number); //进行分割 splitter.split(); } };
文件分割类
class FileSplitter { string m_filePath; int m_fileNumber;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++){ //... } } };
2.需求提出:需要我们在文件分割时显示进度条
主窗口界面
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); } } };
中规中矩的实现方法,也是我们最快能够想到的方法,那么这种方法有没有问题?(八大设计原则)
违背了第一个依赖倒置原则:高层模块不能依赖低层模块,二者都应该依赖抽象,抽象不能依赖实现细节,实现细节应该依赖抽象
依赖(编译时依赖):除非明确说明是运行时依赖,否则我们都认为是编译时依赖
A依赖B:指的是A编译的时候B需要存在才能够编译通过
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); } } };
上面第一处就存在编译时依赖,这个编译关系不太好,这个progressBar就是我们依赖倒置原则所说的实现细节,今天我们实现的这个文件分割器我们使用的是progressBar,但是我们不能保证过一段时间还是以这种形式来展示的,还有许多其他展示方式,例如label,控制台打#或.等符号
会带来实现细节变更时的困扰,这就是为什么抽象不能依赖实现细节,因为实现细节是非常容易变的,例如我们上面提到的几种实现细节是极有可能出现的,所以这种实现不好
有种说法:不要依赖A而要去依赖A的抽象基类(粗浅认识)。这里我们若是去依赖其基类,比如ControlBase基类。可能走人一个死胡同,因为可能父类中没有一些方法比如setvalue,然而我们在文件分割中调用了,就会走入错误
(二)怎样去变化呢?怎么样去重构代码?观察者模式
深入理解到我们真正要解决什么样的问题
progressBar到底扮演了一个什么样的角色? ProgressBar* m_progressBar; //其扮演了一个通知 而这个通知我们可以使用一个相当抽象的实现来表达通知,而不需要一个具体的控件来表达通知
1.添加抽象
class IProgress{ //I是接口的意思 public: virtual void DoProgress(float value)=0; //0-1一个进度值 virtual ~IProgress(){} }; class FileSplitter { string m_filePath; int m_fileNumber; //ProgressBar* m_progressBar// 具体的通知控件 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++; } } };
2.修改主界面
class MainForm : public Form, public IProgress //C++不推荐多继承,因为他会带来很多耦合性问题,但是支持一种,第一个是主继承,其他都是接口或者抽象基类 { TextBox* txtFilePath; TextBox* txtFileNumber; ProgressBar* progressBar; //这里面使用progressBar是没有关系的,他和MainForm本身是一体的,紧耦合的 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){ progressBar->setValue(value); //主界面选择的GUI进度条,我们可以添加,也可以添加addIProgress(this) } }; class ConsoleNotifier : public IProgress { public: virtual void DoProgress(float value){ cout << "."; } };
第一种:不管后面,先把结果抛出,设计品质不好
第二种:看到了耦合性的问题,将其解决了,提升了设计品质
四:模式定义
定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新
五:类图(结构)
其中Observer就是我们抽象基类IProgress
ConcreteObserver是我们具体观察者像ConsoleNotifier
ConcreteSubject是我们具体的文件分割类,具体主题对象,将对所有观察者发送通知
Subject是说:我们应该将Observer中的一些方法提升到父类中去(Subject)
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++; } }
例如上面的3个方法,我们可以单独提升到父类中,当然我们不提升也是一种观察者模式
六:要点总结
(一)使用面向对象的抽象,Observer模式使得我们可以独立地改变目标与观察者,从而使二者之间的依赖关系达到松耦合
我们可以支持多种观察者,但是我们FileSplitter不需要改变,是松耦合,复用性好
(二)目标发送通知时,无需指定观察者,通知(可以携带通知信息作为参数)会自动传播
virtual void onProgress(float value){ List<IProgress*>::iterator itor=m_iprogressList.begin(); while (itor != m_iprogressList.end() ) (*itor)->DoProgress(value); //更新进度条 itor++; } } 我们不需要指定一个具体的实现细节,我们是针对整个通信机制实现自动通知
(三)观察者自己决定是否需要订阅通知,目标对象对此一无所知
splitter.addIProgress(this); //订阅通知 splitter.addIProgress(&cn); //订阅通知
(四)Observer模式是基于事件的UI框架中非常常用(和Template一样常用)的设计模式,也是MVC模式中一个重要组成部分
七:案例实现
class IObserver { public: virtual void update(string action) = 0; virtual ~IObserver(){} }; class Secretary { private: string m_action; vector<IObserver*> v; public: void setAction(string action) { m_action = action; Notify(m_action); } void Notify(string action) { vector<IObserver*>::iterator iter = v.begin(); while (iter!=v.end()) { (*iter)->update(action); iter++; } } void addObserver(IObserver* ob) { v.push_back(ob); } };
class PlayersObserver :public IObserver { private: string m_name; public: PlayersObserver(string name) :m_name(name) { } virtual void update(string action) { cout << this->m_name << " player recv info"<<action << endl; } }; class SleepObserver :public IObserver { private: string m_name; public: SleepObserver(string name) :m_name(name) { } virtual void update(string action) { cout << this->m_name << " sleeping recv info" << action << endl; } }; void main() { Secretary* sec = new Secretary(); PlayersObserver* p = new PlayersObserver("Mark"); SleepObserver* s = new SleepObserver("Marry"); sec->addObserver(p); sec->addObserver(s); sec->setAction("Boss coming"); system("pause"); return; }