概述
- 当用户对象之间存在很强的关联性时，会有以下问题：
- 系统结构负责
- 对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象关联的其他所有对象，并进行适当处理。
- 对象的可重用性差
- 由于一个对象和其他对象具有很强的关联，若没有其他对象的支持，一个对象很难被另一个系统或模块重用，这些对象表现出来更像一个不可分割的整体，职责较为混乱。
- 系统扩展性低
- 增加一个新的对象需要在原有相关对象上增加引用，增加新的引用关系也需要调整原有对象，系统耦合度很高，对象操作很不灵活，扩展性差。
- 对于一个模块，可能由很多对象构成，而且这些对象之间可能存在相互的引用，为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，选择用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
定义
角色
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; } |
实现-智能指针
|
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 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
#include <iostream> #include <mutex> #include <vector> class Colleage; class Mediator { public: ~Mediator() = default; virtual void add(std::shared_ptr<Colleage> colleage) = 0; virtual void distribute(Colleage* sender, const std::string& msg) = 0; }; class Colleage { public: Colleage(std::shared_ptr<Mediator> mediator, unsigned int id) : med_(mediator), id_(id) {} virtual ~Colleage() = default; virtual void send(const std::string& msg) = 0; virtual void receive(const std::string& msg) = 0; virtual unsigned int get_id() const { return id_; } protected: std::weak_ptr<Mediator> med_; private: unsigned int id_; }; class ImplMediator : public Mediator { public: void add(std::shared_ptr<Colleage> colleage) override { std::lock_guard<std::mutex> lock(mut_); vecs_.emplace_back(colleage); } void distribute(Colleage* sender, const std::string& msg) override { std::lock_guard<std::mutex> lock(mut_); for (auto& coll : vecs_) { if (coll->get_id() != sender->get_id()) { coll->receive(msg); } } } private: std::vector<std::shared_ptr<Colleage>> vecs_; std::mutex mut_; }; class ImplColleage : public Colleage { public: ImplColleage(std::shared_ptr<Mediator> mediator, unsigned int id) : Colleage(mediator, id) {} void send(const std::string& msg) override { std::cout << "message " << msg << " send by " << get_id() << std::endl; if (auto med = med_.lock()) { med->distribute(this, msg); } } void receive(const std::string& msg) override { std::cout << "message < " << msg << " > receive from " << get_id() << std::endl; } }; int main() { auto mediator = std::make_shared<ImplMediator>(); auto colleage1 = std::make_shared<ImplColleage>(mediator, 1); auto colleage2 = std::make_shared<ImplColleage>(mediator, 2); auto colleage3 = std::make_shared<ImplColleage>(mediator, 3); mediator->add(colleage1); mediator->add(colleage2); mediator->add(colleage3); std::string msg1("hello"); std::string msg2("world"); colleage1->send(msg1); colleage3->send(msg2); return 0; } |
声明：本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ 行为型：观察者模式08/27
- ♥ 创建型：抽象工厂模式08/26
- ♥ 行为型：状态模式09/24
- ♥ 行为型：模板方法模式09/25
- ♥ 创建型：单例模式05/16
- ♥ 架构模式：MVC模式07/27