设计模式（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;
}

运行结果：

相关推荐
小白不太白95044 分钟前
设计模式之 观察者模式
观察者模式·设计模式
小白不太白9502 小时前
设计模式之 责任链模式
python·设计模式·责任链模式
吾与谁归in2 小时前
【C#设计模式(13)——代理模式(Proxy Pattern)】
设计模式·c#·代理模式
吾与谁归in2 小时前
【C#设计模式(14)——责任链模式( Chain-of-responsibility Pattern)】
设计模式·c#·责任链模式
闲人一枚（学习中）3 小时前
设计模式-创建型-原型模式
设计模式
Iced_Sheep3 小时前
干掉 if else 之策略模式
后端·设计模式
哪 吒10 小时前
最简单的设计模式，抽象工厂模式，是否属于过度设计？
设计模式·抽象工厂模式
Theodore_102210 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
转世成为计算机大神13 小时前
易考八股文之Java中的设计模式？
java·开发语言·设计模式
小乖兽技术14 小时前
23种设计模式速记法
设计模式
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作