概述
当用户对象之间存在很强的关联性时，会有以下问题：
系统结构负责
对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象关联的其他所有对象，并进行适当处理。
对象的可重用性差
由于一个对象和其他对象具有很强的关联，若没有其他对象的支持，一个对象很难被另一个系统或模块重用，这些对象表现出来更像一个不可分割的整体，职责较为混乱。
系统扩展性低
增加一个新的对象需要在原有相关对象上增加引用，增加新的引用关系也需要调整原有对象，系统耦合度很高，对象操作很不灵活，扩展性差。
对于一个模块，可能由很多对象构成，而且这些对象之间可能存在相互的引用，为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，选择用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
定义
角色
Mediator:抽象中介者ConcreteMediator:具体中介者Colleague:抽象同事类ConcreteColleague:具体同事类
场景
- 一组对象以一种定义明确但是很复杂的方式通信或交互
- 对象重用很困难，因为这个对象不仅引用了大量对象，还和大量对象通信或交互
- 多个类之间分布的行为应可以自定义，而无须大量子类化
实现
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
class Mediator; //抽象同事类 class Colleague { public: Colleague(Mediator * const m,const unsigned int i):mediator(m),id(i) { } virtual ~Colleague() {} unsigned int GetId() { return id; } virtual void send(std::string) = 0; virtual void receive(std::string) = 0; protected: Mediator * mediator; unsigned int id; }; //具体同事类 class ConcreteColleague : public Colleague { public: ConcreteColleague(Mediator * const m,const unsigned int i):Colleague(m,i) { } ~ConcreteColleague() {} void send(std::string msg) { std::cout << "message '" << msg << "' sent by Colleague " << id << std::endl; mediator->distribute(this,msg); } void receive(std::string msg) { std::cout << "message '" << msg << "' received by Colleague " << id << std::endl; } }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//抽象中介者类 class Mediator { public: virtual ~Mediator() {} virtual void add(Colleague * const c) = 0; virtual void distribute(Colleague * const sender,std::string msg) = 0; protected: Mediator() {} }; //具体中介者类 class ConcreteMediator : public Mediator { public: ~ConcreteMediator() { for (unsigned int i = 0; i < colleagues.size(); i++) { delete colleagues[i]; } colleagues.clear(); } void add(Colleague * const c) { colleagues.push_back(c); } void distribute(Colleague * const sender,std::string msg) { for (unsigned int i = 0; i < colleagues.size(); i++) { if (colleagues.at(i)->GetId() != sender->GetId()) { colleagues.at(i)->receive(msg); } } } private: std::vector<Colleague*> colleagues; }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
auto main()->int { Mediator * mediator = new ConcreteMediator(); Colleague * c1 = new ConcreteColleague(mediator,1); Colleague * c2 = new ConcreteColleague(mediator,2); Colleague * c3 = new ConcreteColleague(mediator,3); mediator->add(c1); mediator->add(c2); mediator->add(c3); c1->send("hi"); c3->send("hello"); delete mediator; return 0; } |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ 行为型：解释器模式09/25
- ♥ 架构模式：MVP模式07/28
- ♥ 行为型：策略模式09/07
- ♥ 结构型：代理模式09/23
- ♥ 创建型：工厂方法模式08/25
- ♥ 结构型：适配器模式09/19