一：概念
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;
}
