5-观察者模式(Observer)

1. 动机

• 在软件构建过程中，我们需要为某些对象建立一种 “通知依赖关系”，
  即 一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。
  如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。
• 使用面向对象技术，可将这种依赖关系弱化，
  并形成一种稳定的依赖关系，从面实现软件体系结构的松耦合。
  • 独立 - 松耦合 - 更加灵活 且一般包含兼容紧耦合
  • 捆绑 - 紧耦合 - 死板 不能灵活地应对变化
  • 代码独立 -> 抽象类 + 实现类 + 松耦合

2. 模式定义

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

实例：

• 文件分割程序，将大文件分割成若干个小文件
• 分割进度条实时显示【依赖关系-通知-自动更新】

/* 未使用 观察者模式 */

//MainForm1.cpp
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 splitter(filePath, number, progressBar);//实例 初始化splitter分割器

		splitter.split();//进行分割

	}
};

//FileSplitter.cpp
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);//更新进度条
		}

	}
};
/*
	不利于应对未来的需求变更
		-以其他的方式显示进度 ( 修改源代码来解决 不提倡 )
		-同时可支持其他界面进行展示进度 GUI/window/mac and so on
		
	违背依赖导致原则
	高层模块不应该依赖于底层模块
	抽象不应该依赖于实现细节(变化)
		-实现细节: progressBar
	而且这只能实现一对一的依赖关系
*/

对于观察者问题，不好的设计是发送方（目标对象）直接记录全部的观察者（依赖对象），
这在扩展时会违背依赖倒置原则，即发送方作为高层模块，
在发送通知时要根据不同的观察者来使用不同的方式进行发送，
也就是要依赖低层模块观察者的具体行为，这也容易陷入大量的条件判断语句中。

好的设计是发送方先抽象出一个观察者的抽象类，
这个抽象类只提供发送通知的接口，发送方记录的是抽象类的对象数组。
全部的观察者继承自该抽象类并实现接口。
由于观察者不止一个，所以发送方一般要提供添加和删除观察者的接口，
比如add/del，或attach/detach。

/* 观察者模式 */

//MainForm2.cpp
class MainForm : public Form, public IProgress{
//C++支持多继承, 不推荐
//但这里多继承情况比较特别, 泛化一个类 + 实现一个接口
	TextBox* txtFilePath;
	TextBox* txtFileNumber;

	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){
		progressBar->setValue(value);
	}
};

class ConsoleNotifier : public IProgress {//增加控制台进度条通知器
public:
	virtual void DoProgress(float value){
		cout << ".";
	}
};

//FileSplitter2.cpp
class IProgress{//Interface Progress 抽象进度条接口
public:
	virtual void DoProgress(float value)=0;
	virtual ~IProgress(){}
};


class FileSplitter{
	string m_filePath;
	int m_fileNumber;
	
    //链表的数据结构 支持多个观察者
	List<IProgress*>  m_iprogressList; // 抽象通知机制 支持多个观察者
	
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++;
		}
	}
};
//松耦合 - 活字印刷
/*
	这里的做法, 是 "Subject" 和 "ConcreteSubject" 合二为一
	可拆开可合并
	拆开, 就将 'addIProgress' + 'removeIProgress' + 'onProgress' 抽象成一个 "Subject" 基类
	然后使 "ConcreteSubject" 继承并实现它
	
	观察者模式Observer 可有不同的表现形式
	最关键的是 抽象的通知依赖关系
*/

3. 结构

• Observer - IProgress
• Updare() - DoProgress
• Attach(Observe) - addIProgress
• Detach - removeIProgress
• Notify - onProgress
• Subject ConcreteSubject - FileSplitter
• ConcreteObserver - MainForm or ConsoleNotifier

稳定的部分：

• Subject
• Observer

变化的部分：

• ConcreteSubject
• ConcreteObserver

4. 要点总结

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