浅谈观察者模式

观察者模式（Observer）

使用场景：

当对象间存在着一对多关系的时候，往往会采用观察者模式，比如说，当一个对象发生改变时，需要自动通知所有依赖它的对象，这个时候，我们就可以采用这种设计模式，该模式属于行为型模式。

例子：

众所周知，在平时构建软件系统体系结构的时候，我们往往会采用MVC模式，即“模型——视图——控制器”，在该模型中，视图与数据应当是分离的，它们间的耦合度应该尽可能松散，以达到解耦的效果。它们间的松耦合关系一般可以采用观察者模式来给予实现。

模板代码可以这样子设计

1.定义观察者接口，所有视图类必须继承该接口

该虚基类将update方法定义为纯虚函数，强制继承该接口的子类必须实现该函数。

#pragma once
#include <memory>

class Observer {
public:
	virtual ~Observer() = default;
	virtual int getId() = 0;
	virtual void update() = 0;
};

using ObserverPtr = std::shared_ptr<Observer>;

Observer用于观察Subject，因此，它们应该可以被允许在Subject类上注册，也可以注销

2.设计Subject接口，所有数据类必须继承该接口

#pragma once

#include "Observer.h"
#include <algorithm>
#include <vector>

class IsEqualTo final {
public:
	explicit IsEqualTo(const ObserverPtr& observer) :observer{ observer } {}
	bool operator()(const ObserverPtr& observerToCompare)
	{
		return observerToCompare->getId() == observer->getId();
	}
private:
	ObserverPtr observer;
};

class Subject {
public:
	void addObserver(ObserverPtr& observerToAdd)
	{
		auto iter = std::find_if(begin(observers), end(observers), IsEqualTo(observerToAdd));
		if (iter == end(observers))
		{
			observers.push_back(observerToAdd);
		}
	}

	void removeObserver(ObserverPtr& observerToRemove)
	{
		observers.erase(std::remove_if(begin(observers), end(observers), IsEqualTo(observerToRemove)),
			end(observers));
	}
protected:
	void notifyAllObservers() const
	{
		for (const auto& observer : observers)
		{
			observer->update();
		}
	}
private:
	std::vector<ObserverPtr> observers;
};

为了便于通知到所有的observer对象，需要定义一个notifyAllObservers方法，同时将该方法定义为protected，因为该方法是被设计为Subject子类调用的方法。在该方法中，调用所有注册在该Subject中的Observer的update方法用于更新视图。

3.定义具体的Subject类（数据类）

#pragma once

#include "Subject.h"
#include <iostream>

class SpreadsheetModel : public Subject {
public:
	void changeCellValue(std::string column, const int row, const double value)
	{
		std::cout << "Cell[" << column.c_str() << "," << row << "] = " << value << std::endl;
		Subject::notifyAllObservers();
	}
};

该类定义了一个打印数据的函数，同时调用基类的notifyAllObservers接口通知所有注册在该类的观察者对象（视图对象）

4.定义具体的Observer类（视图类）

#pragma once

#include "Observer.h"
#include "SpreadsheetModel.h"
#include <iostream>

class TableView : public Observer {
public:
	explicit TableView(SpreadsheetModel& theModel):model{theModel}{}

	virtual int getId() override
	{
		return 1;
	}

	virtual void update() override
	{
		std::cout << "Update of TableView" << std::endl;
	}
private:
	SpreadsheetModel& model;
};

class BarChartView : public Observer
{
public:
	explicit BarChartView(SpreadsheetModel& theModel):model{theModel}{}

	virtual int getId() override
	{
		return 2;
	}

	virtual void update() override
	{
		std::cout << "Update of BarChartView" << std::endl;
	}
private:
	SpreadsheetModel& model;
};

class PieChartView : public Observer
{
public:
	explicit PieChartView(SpreadsheetModel& theModel) : model{theModel}{}

	virtual int getId() override
	{
		return 3;
	}

	virtual void update() override
	{
		std::cout << "Update of PieChartView" << std::endl;
	}
private:
	SpreadsheetModel& model;
};

上述类的关系如下图所示：

当spreadsheetmodel发生变化时，它会通知所有的observer

测试程序如下：

#include "stdafx.h"
#include "SpreadsheetModel.h"
#include "View.h"

int main()
{
	SpreadsheetModel spreadSheetModel{ };

	ObserverPtr observer1 = std::make_shared<TableView>(spreadSheetModel);
	spreadSheetModel.addObserver(observer1);

	ObserverPtr observer2 = std::make_shared<BarChartView>(spreadSheetModel);
	spreadSheetModel.addObserver(observer2);

	spreadSheetModel.changeCellValue("A", 1, 42);
	spreadSheetModel.removeObserver(observer1);

	spreadSheetModel.changeCellValue("B", 2, 66.6);

	ObserverPtr observer3 = std::make_shared<PieChartView>(spreadSheetModel);
	spreadSheetModel.addObserver(observer3);

	spreadSheetModel.changeCellValue("C", 3, 188);

    return 0;
}

编译并运行程序后，结果如下：

除了松耦合外，该模式还很好支持了开闭原则，在无需调整或更改现有类的任何内容，我们可以非常轻松地添加新的具体的Observer。