设计模式_21 中介者模式

• 21 中介者模式
• • 21.1 概念
  • 21.2 结构
  • 21.3 实现
  • • 21.3.1 UML图
    • 21.3.2 代码
  • 21.4 优缺点
  • • 21.4.1 优点
    • 21.4.2 缺点
  • 21.5 使用场景
• return 设计模式概述;

21 中介者模式

21.1 概念

定义一个中介角色来封装一系列对象之间的交互，使原有对象之间耦合松散，且可独立的改变他们之间的交互。
多个类之间互相关联，呈现复杂网状结构，过度耦合。引入中介者模式，将类之间关系变为星型结构。任何一个类的变动只会影响类本身和中介者。

21.2 结构

抽象中介者角色：定义了中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
具体中介者角色：实现中介者接口，定义一个list来管理同事对象，协调各个同事角色之间的交互关系。
抽象同事类角色：定义了同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
具体同事类角色：实现抽象同事类角色，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

21.3 实现

21.3.1 UML图

21.3.2 代码

MediatorAndPerson.h：

#ifndef  _MEDIATORANDPERSON_H_
#define _MEDIATORANDPERSON_H_

#include<iostream>
#include<string>
#include<list>
using namespace std;

class Person;
class Tenant;
class HouseHolder;

class Mediator {
public:
	virtual void constactTenant(string message, Tenant* tenant) = 0;
	virtual void constactHouseHolder(string message, HouseHolder* houseHolder) = 0;
};

class ConcreteMediator : public Mediator {
private:
	list<Tenant*> tenants;
	list<HouseHolder*> houseHolders;
public:
	void addHouseHolder(HouseHolder* houseHolder);
	void deleteHouseHolder(HouseHolder* houseHolder);
	void addTenant(Tenant* tenant);
	void deleteTenant(Tenant* tenant);
	void constactTenant(string message, Tenant * tenant);
	void constactHouseHolder(string message, HouseHolder* houseHolder);
};

class Person {
protected:
	string name;
	ConcreteMediator* mediator;
public:
	Person(string name, ConcreteMediator* mediator);
};

class Tenant : public Person {
public:
	Tenant(string name, ConcreteMediator* mediator);
	void constact(string message);
	void getMessage(string message);
	virtual ~Tenant();
};

class HouseHolder : public Person {
public:
	HouseHolder(string name, ConcreteMediator* mediator);
	void constact(string message);
	void getMessage(string message);
	virtual ~HouseHolder();
};

#endif

MediatorAndPerson.cpp：

#include"MediatorAndPsrson.h"

//中介类
void ConcreteMediator::addHouseHolder(HouseHolder* houseHolder) {
	houseHolders.push_back(houseHolder);
}
void ConcreteMediator::deleteHouseHolder(HouseHolder* houseHolder) {
	houseHolders.remove(houseHolder);
}
void ConcreteMediator::addTenant(Tenant* tenant) {
	tenants.push_back(tenant);
}
void ConcreteMediator::deleteTenant(Tenant* tenant) {
	tenants.remove(tenant);
}
void ConcreteMediator::constactTenant(string message, Tenant* tenant) {
	for (auto it : this->houseHolders) {
		(*it).getMessage(message);
	}
}
void ConcreteMediator::constactHouseHolder(string message, HouseHolder* houseHolder) {
	for (auto it : this->tenants) {
		(*it).getMessage(message);
	}
}

//同事类
Person::Person(string name, ConcreteMediator* mediator) {
	this->name = name;
	this->mediator = mediator;
}

//租户类
Tenant::Tenant(string name, ConcreteMediator* mediator) : Person(name, mediator) {
	mediator->addTenant(this);
}
void Tenant::constact(string message) {
	this->mediator->constactTenant(this->name+"的需求为："+message, this);
}
void Tenant::getMessage(string message) {
	cout << this->name << "收到消息：\n" << message << endl <<endl;
}
Tenant::~Tenant() {
	this->mediator->deleteTenant(this);
}

//房屋拥有者类
HouseHolder::HouseHolder(string name, ConcreteMediator* mediator) : Person(name, mediator) {
	mediator->addHouseHolder(this);
}
void HouseHolder::constact(string message) {
	this->mediator->constactHouseHolder(this->name + "的需求为：" + message, this);
}
void HouseHolder::getMessage(string message) {
	cout <<this->name <<"收到消息：\n" << message << endl << endl;
}
HouseHolder::~HouseHolder() {
	this->mediator->deleteHouseHolder(this);
}

main.cpp：

#include"MediatorAndPsrson.h"

int main() {
	ConcreteMediator* mediator = new ConcreteMediator();
	Tenant* tenant1 = new Tenant("租房者1", mediator);
	Tenant* tenant2 = new Tenant("租房者2", mediator);
	HouseHolder* houseHolder1 = new HouseHolder("房主1", mediator);
	HouseHolder* houseHolder2 = new HouseHolder("房主2", mediator);
	tenant1->constact("需要一个一室的房子");
	houseHolder2->constact("有一个三室两厅的房子");
	return 0;
}

21.4 优缺点

21.4.1 优点

松散耦合。把多个同事对象之间的交互封装到中介者对象里，从而使得同事对象之间耦合松散，使得同事对象可以独立变化和复用。
集中控制交互。多个同事对象的交互被封装在中介者对象里统一管理，使得交互行为发生变化时只需要修改中介对象即可。
一对多的关联转变为一对一的关联。使得关系更加易于理解。

21.4.2 缺点

同事类太多时，中介者会变得很庞大，难以维护。

21.5 使用场景

系统中存在复杂的引用关系，系统结构混乱且难以理解。
当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

return 设计模式概述;

返回设计模式概述