观察者模式(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。