设计模式---组件协作模式之观察者模式(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 = ; 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 = ; 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 = ; i < m_fileNumber; i++){
//...
float progressValue = m_fileNumber;
progressValue = (i + ) / 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 = ; i < m_fileNumber; i++){
//... float progressValue = m_fileNumber;
progressValue = (i + ) / 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) = ;
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;
}
设计模式---组件协作模式之观察者模式(Observer)的更多相关文章
- 设计模式---组件协作模式之模板方法模式(Tempalte Method)
前提:组件协作模式 现代软件专业分工之后的第一个结构是“框架与应用程序的划分”,“组件协作”模式通过晚期绑定,来实现框架与应用程序之间的松耦合,是二者之间协作时常见的模式. 我们常常使用框架来写自己的 ...
- 设计模式----行为型模式之观察者模式(Observer Pattern)
下面是阅读<Head First设计模式>的笔记. 观察者模式 定义了对象之间的一对多依赖,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新. JDK API内置机制 ...
- 设计模式---组件协作模式之策略模式(Strategy)
一:概念 Strategy模式,对一系列的算法加以封装,为所有算法定义一个抽象的算法接口,并通过继承该抽象算法接口对所有的算法加以封装和实现,具体的算法选择交由客户端决定(策略). Strategy模 ...
- C++设计模式 之 “组件协作”模式:Template Method、Strategy、Observer
“组件协作”模式: #现代软件专业分工之后的第一个结果是“框架与应用程序的划分”,“组件协作”模式通过晚期绑定,来实现框架与应用程序之间的松耦合,是二者之间协作时常用的模式. #典型模式: Templ ...
- 学习记录:《C++设计模式——李建忠主讲》3.“组件协作”模式
“组件协作”模式:现代软件专业分工之后的第一个结果是“框架与应用程序的划分”,“组件协作”模式通过晚期绑定,来实现框架与应用程序之间的松耦合,是二者之间协作时常用的模式.典型模式:Template M ...
- 23种设计模式 - 组件协作(TemplateMethod - Observer/Event - Strategy)
其他设计模式 23种设计模式(C++) 每一种都有对应理解的相关代码示例 → Git原码 ⌨ 组件协作 现代软件专业分工之后的第一个结果是"框架与应用程序的划分","组件 ...
- 设计模式13---设计模式之观察者模式(Observer)(行为型)
1.场景模式抽象 订阅报纸的过程,如果报纸来了的时间不确定,那么订报纸的人如何知道呢?可以抽象为:当一个对象的状态发生改变的时候,如何让依赖他的所有对象得到通知,并进行相应的处理呢?生活中最常见的例子 ...
- 十一个行为模式之观察者模式(Observer Pattern)
定义: 定义对象之间一种一对多的关系,当被观察者状态变化时,可以自动地通知观察者并执行相关的业务操作.观察者模式又被称为发布-订阅模式等. 结构图: Subject:抽象主题类,定义了所有被观察类的通 ...
- java设计模式--事件监听器模式(观察者模式)
这两个模式实质上很简单,在实际项目中也是非常常用的.但却被有些人说的云里雾里,这里用白话解释一下. 本质上两者都是同一个模式.专业的说法是这样的(觉得绕口的请直接转到白话解释部分,再回头来看下面这几句 ...
随机推荐
- Atcoder D - Knapsack 1 (背包)
D - Knapsack 1 Time Limit: 2 sec / Memory Limit: 1024 MB Score : 100100 points Problem Statement The ...
- 每天学习SQL
SELECT table_name FROM information_schema.tables WHERE table_schema='survey170227_main' AND table_na ...
- Which path should be used jdk or jre for JAVA_HOME environment variable?
https://stackoverflow.com/questions/17601827/which-one-should-java-home-to-point-jdk-or-jre 临时变更JAVA ...
- Java并发—synchronized关键字
synchronized关键字的作用是线程同步,而线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏. synchronized用法 1. 在需要同步的方法的方法签名中加入synchro ...
- Oracle 数据库启动过程
一 启动数据库 Oracle启动过程涉及几种模式,这些模式涉及不同的文件,每个状态下数据库做不同的事情,同时这些模式适用于不同的维护需求,主要的模式有三种:NOMOUNT.MOUNT.OPEN. 1 ...
- Windows 安装 docker 以及1709的简单使用
PS C:\> Install-Module -Name DockerMsftProvider -Repository PSGallery -Force PS C:\> Install-P ...
- [转帖] “王者对战”之 MySQL 8 vs PostgreSQL 10
原贴地址:https://www.oschina.net/translate/showdown-mysql-8-vs-postgresql-10?lang=chs&page=2# 英文原版地址 ...
- 洛谷 P4294 [WC2008]游览计划
题目链接 不是很会呢,但似乎抄了题解后有点明白了 sol:状态DP显然,其实是要构建一棵最小生成树一样的东西,我自己的理解(可能不是很对哦希望多多指教)f[x][y][zt]就是到x,y这个点,状态为 ...
- Linux管理用户和组
用户管理相关命令useradd 添加用户adduser 添加用户userdel 删除用户passwd 为用户设置密码usermod ...
- LightOJ - 1265 (概率)
题意: 1.两只老虎相遇 就互相残杀 2.老虎与鹿相遇 鹿死 3.老虎与人相遇 人死 4.人与鹿相遇 鹿死 5.鹿与鹿相遇 无果 求人活的概率 解析:如果老虎为0 则人活得概率为1 ...