Modo intermediario en modo diseño (C++)

Autor: Zhai Tianbao Steven
Declaración de derechos de autor: Los derechos de autor pertenecen al autor. Para reimpresión comercial, comuníquese con el autor para obtener autorización. Para reimpresión no comercial, indique la fuente

1. ¿Qué es el modelo intermediario?

       El modo mediador es un modo de diseño de software de comportamiento, también conocido como el modo árbitro.Como sugiere el nombre, el papel de este modo es ser un intermediario para ayudar a otras clases a comunicarse bien.

       Cuando la relación entre clases es caótica, habrá un fuerte acoplamiento. Tomemos como ejemplo el alquiler de una casa, si hay 10 inquilinos y 5 propietarios, y se comunican entre ellos a través de una sola línea, la comunicación entre ellos será relativamente caótica y el mantenimiento será mucho más complicado. En este momento aparece una agencia inmobiliaria, que integra la información del arrendatario y el arrendador, y el intermediario organiza la comunicación adecuada entre el arrendatario y el arrendador, para que la comunicación sea eficiente y clara, y por supuesto hay una tarifa. (como agregar una sobrecarga de mantenimiento de código de clase intermedia).

       Ventajas del modelo mediador:

1. Desacoplamiento. La existencia del intermediario elimina la fuerte relación de acoplamiento entre colegas, y se pueden cambiar de forma independiente sin afectar el conjunto, que es fácil de reutilizar.
2. Buena escalabilidad. Cambios en el comportamiento de interacción, simplemente extendiendo el mediador.
3. Interacción centralizada para una fácil gestión.

      Desventajas del modelo mediador:

1. El papel de un mediador es importante y complejo.

2. Modelo intermediario

2.1 Diagrama de estructura

       El cliente es la función principal, y el humano y el intermediario están relacionados entre sí.

2.2 Ejemplo de código

       Descripción de la escena: El propietario y el inquilino se comunican a través de una agencia inmobiliaria.

//Mediator.h
/****************************************************/
#pragma once
#include <iostream>
#include <unordered_map>
#include <vector>
#include <list>
#include <string>

using namespace std;

class Person;

// 抽象中介者
class Mediator 
{
public:
	// 发出信息
	virtual void sendMessage(std::string message, Person* colleague) = 0;

};

// 抽象类-人
class Person
{
public:
	// 构造函数
	Person(Mediator* mediator) : m_mediator(mediator) {}

	// 发出消息
	virtual void sendMessage(std::string message) = 0;

	// 获取消息
	virtual void getMessage(std::string message) = 0;

protected:
	Mediator* m_mediator;
};

// 具体类-租客
class Tenant : public Person
{
public:
	// 构造函数
	Tenant(Mediator* mediator) : Person(mediator) {}

	// 发出消息
	virtual void sendMessage(std::string message) {
		m_mediator->sendMessage(message, this);
	}

	// 获取消息
	virtual void getMessage(std::string message) {
		std::cout << "租客得到消息：" << message << std::endl;
	}
};

// 具体类-房东
class Landlord : public Person 
{
public:
	// 构造函数
	Landlord(Mediator* mediator) : Person(mediator) {}

	// 发出消息
	virtual void sendMessage(std::string message) {
		m_mediator->sendMessage(message, this);
	}

	// 获取消息
	virtual void getMessage(std::string message) {
		std::cout << "房东得到消息：" << message << std::endl;
	}
};

// 具体中介者-房产中介
class RealEstateMediator : public Mediator
{
public:
	// 设置租客
	void setTenant(Person* tenant) {
		m_tenant = tenant;
	}

	// 设置房东
	void setLandlord(Person* landlord) {
		m_landlord = landlord;
	}

	// 发出信息
	virtual void sendMessage(std::string message, Person* colleague) {
		if (colleague == m_tenant) {
			m_landlord->getMessage(message);
		}
		else {
			m_tenant->getMessage(message);
		}
	}

private:
	Person* m_tenant;
	Person* m_landlord;

};

//main.cpp
/****************************************************/
#include <iostream>
#include <string>
#include "Iterator.h"

using namespace std;

int main() 
{
	// 创建对象
	RealEstateMediator *mediator = new RealEstateMediator();
	Person *tenant = new Tenant(mediator);
	Person *landlord = new Landlord(mediator);

	// 中介设置房东和租客
	mediator->setTenant(tenant);
	mediator->setLandlord(landlord);

	// 进行租房询问
	tenant->sendMessage("房租多少钱？");
	landlord->sendMessage("房租3000元。");

	// 删除
	delete mediator;
	delete tenant;
	delete landlord;
	mediator = nullptr;
	tenant = nullptr;
	landlord = nullptr;

	return 0;
}

       Los resultados del programa son los siguientes.

       El inquilino envía un mensaje al agente y el agente transmite el mensaje al propietario y viceversa.

3. Resumen

       Hago todo lo posible para expresar mi comprensión del modelo intermediario con palabras más comunes y rutinas de código intuitivas. Puede haber algunos lugares que no sean reflexivos. Si tiene opiniones diferentes, ¡bienvenido a comunicarse en el área de comentarios! Espero que mi ejemplo lo ayude a comprender mejor el patrón del mediador.

       Si el artículo te ayuda, puedes darme un me gusta para avisarme, estaré muy feliz ~ ¡Vamos!