设计模式（4）--对象行为(7)--观察者

myepicure8882023-12-30 9:42
1. 意图

定义对象间的一种一对多的依赖关系，

当一个对象的状态改变时，所有依赖于它的对象都得到通知并被自动更新。

2. 四种角色

抽象目标(Subject)、具体目标(Concrete Subject)、抽象观察者(Observer)、

具体观察者(Concrete Observer)

3. 优点

3.1 目标和观察者之间的耦合是抽象的。

3.2 支持广播通信。

4. 缺点

4.1 可能导致意外的更新。

5. 相关模式

当目标和观察者间的依赖关系特别复杂时，需要一个维护这些关系的对象，

这样的对象称为ChangeMananger。

5.1 ChangeManager可使用单例模式来保证它是唯一的并且是可全局访问的。

5.2 ChangeManager充当目标和观察者之间的Mediator

6. 代码示意(C++)
cpp 复制代码 
#pragma once
#include <string>
#include <iostream>
#include <vector>
using namespace std;

class Subject;

class Observer
{
public:
	virtual void Update(Subject* pSubject) = 0;
protected:
	Observer() {}
};
class ConcreteObserver :public Observer
{
	string m_state;
	string m_name;
public:
	ConcreteObserver(const string& name) :m_name(name) {
	}
	virtual void Update(Subject* pSubject);
};

class Subject
{
	vector<Observer*> m_observers;
public:
	virtual string GetState() = 0;
	virtual void SetState(const string& state) = 0;
public:
	void Attach(Observer* pObserver) {
		m_observers.emplace_back(pObserver);
		cout << "After attached, observers size is:" << m_observers.size() << endl;
	}
	void Detach(Observer* pObserver) {
		m_observers.erase(std::remove_if(m_observers.begin(), m_observers.end(), [&](Observer* p) { return p == pObserver; }), m_observers.end());
		cout << "After detached, observers size is:" << m_observers.size() << endl;
	}
	void Notify()
	{
		auto it = m_observers.begin();
		while (it != m_observers.end()) {
			(*it)->Update(this);
			++it;
		}
	}
protected:
	Subject(){}
};
class ConcreteSubject :public Subject
{
	string m_state;
public:
	virtual string GetState() {
		return m_state;
	}
	virtual void SetState(const string& state) {
		m_state = state;
	}
};

Observer.cpp:

cpp 复制代码 
#include "Observer.h"

void ConcreteObserver::Update(Subject* pSubject) {
	m_state = pSubject->GetState();
	cout << "Observer:" << m_name << ",got state from subject:" << m_state << endl;
}
cpp 复制代码 
#include "Observer.h"
int main() {
	Subject* pSubject = new ConcreteSubject();

	Observer* pObserver1 = new ConcreteObserver("obs1");
	Observer* pObserver2 = new ConcreteObserver("obs2");

	pSubject->Attach(pObserver1);
	pSubject->Attach(pObserver2);

	pSubject->SetState("hello1");
	pSubject->Notify();

	pSubject->Detach(pObserver1);
	pSubject->SetState("hello2");
	pSubject->Notify();

	delete pObserver2;
	delete pObserver1;
	delete pSubject;
	return 0;
}

运行结果：

6.1 目标和观察者之间只知道彼此的抽象类(3.1)。

6.2 Subject::Notify里的循环就是广播，观察者自己决定是否处理某一通知(3.2)。

6.3 使用ChangeMananger会使代码复杂些，但简化了Subject，且使更新策略更加灵活。

使用ChangeMananger代码示意：

cpp 复制代码 
#pragma once
#include <string>
#include <iostream>
#include <vector>
#include <map>
using namespace std;

class Subject;

class Observer
{
public:
	virtual void Update(Subject* pSubject) = 0;
	virtual string GetName() = 0;
protected:
	Observer() {}
};
class ConcreteObserver :public Observer
{
	string m_state;
	string m_name;
public:
	ConcreteObserver(const string& name) :m_name(name) {
	}
	virtual string GetName() { return m_name; }
	virtual void Update(Subject* pSubject);
};

class ChangeManager;
class SimpleChangeManager;

class Subject
{
	ChangeManager* m_pChangeManager;
public:
	virtual string GetState() = 0;
	virtual void SetState(const string& state) = 0;
	virtual ~Subject();
public:
	void Attach(Observer* pObserver);
	void Detach(Observer* pObserver);
	void Notify();
protected:
	Subject();
};
class ConcreteSubject :public Subject
{
	string m_state;
public:
	ConcreteSubject() {
	}
	virtual string GetState() {
		return m_state;
	}
	virtual void SetState(const string& state) {
		m_state = state;
	}
};

class ChangeManager
{
public:
	virtual void Register(Subject* pSubject, Observer* pObserver) = 0;
	virtual void Unregister(Subject* pSubject, Observer* pObserver) = 0;
	virtual void Notify() = 0;
protected:
	ChangeManager() {}
};

class SimpleChangeManager :public ChangeManager
{
	map<Subject*, vector<Observer*> > m_mapSubjects;
private:
	static SimpleChangeManager* s_instance;
public:
	static ChangeManager* Instance() {
		if (0 == s_instance) {
			s_instance = new SimpleChangeManager();
		}
		return s_instance;
	}
    static void DelInstance() {
		delete s_instance;
		s_instance = 0;
	}
public:
	virtual void Register(Subject* pSubject, Observer* pObserver) {
		vector<Observer*>& observers = m_mapSubjects[pSubject];
		auto it = find(observers.begin(), observers.end(), pObserver);
		if (it == observers.end()) {
			observers.emplace_back(pObserver);
			cout << pObserver->GetName() << " is registered successful" << endl;
		}
		else {
			cout << pObserver->GetName() << " is already registered" << endl;
		}
	}
	virtual void Unregister(Subject* pSubject, Observer* pObserver) {
		auto it = m_mapSubjects.find(pSubject);
		if (it == m_mapSubjects.end()) {
			cout << "No need unregister in map for:" << pObserver->GetName() << endl;
		}
		else {
			vector<Observer*>& observers = m_mapSubjects[pSubject];
			auto itRemove = remove_if(observers.begin(), observers.end(), [&](Observer* p) { return p == pObserver; });
			if (itRemove == observers.end()) {
				cout << "No need unregister in vector for:" << pObserver->GetName() << endl;
			}
			else {
				observers.erase(itRemove, observers.end());
				cout << pObserver->GetName() << " is unregistered successful" << endl;
				if (observers.size() == 0) {
					m_mapSubjects.erase(pSubject);
				}
			}
		}
	}
	virtual void Notify() {
		for (auto& pair : m_mapSubjects) {
			vector<Observer*>& observers = pair.second;
			auto it = observers.begin();
			while (it != observers.end()) {
				(*it)->Update(pair.first);
				++it;
			}
		}
	}
protected:
	SimpleChangeManager() {}
};

Observer.cpp:

cpp 复制代码 
#include "Observer.h"

void ConcreteObserver::Update(Subject* pSubject) {
	m_state = pSubject->GetState();
	cout << "Observer:" << m_name << ",got state from subject:" << m_state << endl;
}

Subject::Subject() {
	m_pChangeManager = SimpleChangeManager::Instance();
}
Subject::~Subject() {
	m_pChangeManager = 0;
	SimpleChangeManager::DelInstance();
}
void Subject::Attach(Observer* pObserver) {
	m_pChangeManager->Register(this, pObserver);
}
void Subject::Detach(Observer* pObserver) {
	m_pChangeManager->Unregister(this, pObserver);
}
void Subject::Notify()
{
	m_pChangeManager->Notify();
}

SimpleChangeManager* SimpleChangeManager::s_instance = 0;
cpp 复制代码 
#include "Observer.h"
int main() {

	Subject* pSubject = new ConcreteSubject();

	Observer* pObserver1 = new ConcreteObserver("obs1");
	Observer* pObserver2 = new ConcreteObserver("obs2");

	pSubject->Attach(pObserver1);
	pSubject->Attach(pObserver2);
	pSubject->Attach(pObserver1);

	pSubject->SetState("hello1");
	pSubject->Notify();

	pSubject->Detach(pObserver1);
	pSubject->Detach(pObserver1);
	pSubject->SetState("hello2");
	pSubject->Notify();

	pSubject->Detach(pObserver2);
	pSubject->Detach(pObserver2);

	delete pObserver2;
	delete pObserver1;
	delete pSubject;
	return 0;
}

运行结果：

相关推荐
至此流年莫相忘3 分钟前
设计模式：模板方法模式
java·开发语言·设计模式
o0向阳而生0o6 小时前
100、23种设计模式之适配器模式（9/23）
设计模式·适配器模式
将编程培养成爱好7 小时前
C++ 设计模式《外卖菜单展示》
c++·设计模式
TechNomad15 小时前
设计模式：状态模式（State Pattern）
设计模式·状态模式
努力也学不会java15 小时前
【设计模式】 原型模式
java·设计模式·原型模式
TechNomad18 小时前
设计模式：模板方法模式（Template Method Pattern）
设计模式·模板方法模式
leo030820 小时前
7种流行Prompt设计模式详解：适用场景与最佳实践
设计模式·prompt
ytadpole1 天前
揭秘设计模式：工厂模式的五级进化之路
java·设计模式
烛阴1 天前
【TS 设计模式完全指南】用工厂方法模式打造你的“对象生产线”
javascript·设计模式·typescript
_请输入用户名1 天前
EventEmitter 是广播，Tapable 是流水线：聊聊它们的本质区别
前端·设计模式
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！02UV安装并设置国内源032025年数学建模国赛C题超详细解题思路04不再让Windows更新！&Edge游戏助手卸载及关闭自动更新05A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程062025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定07KGG转MP3工具|非KGM文件|解密音频08解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题09教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员10UV 工具安装与国内镜像源配置指南