设计模式实现（二十一）---中介者模式(Mediator)

中介者模式(Mediator)：用一个中介对象来分装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互。



Colleague叫做抽象同事类，而ConcreteColleague是具体同事类，每个具体同事只知道自己的行为，而不了解其他同事类的情况，但它们却都认识中介者对象，Mediator是抽象中介者，定义了同事对象到中介者对象的接口，ConcreteMediator是具体中介者对象，实现抽象类的方法，它需要知道所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令。

#include <string>
#include <iostream>
using namespace std;
class Colleague;
//Mediator类，抽象中介者
class Mediator
{
public:
virtual void Send(string message,Colleague *colleague) = 0;
};
//Colleague类，抽象同事类
class Colleague
{
protected:
Mediator *mediator;
public:
Colleague(Mediator *mediator)
{
this->mediator = mediator;
}
};
//ConcreteColleague类，具体同事类
class ConcreteColleague1 : public Colleague
{
public:
ConcreteColleague1(Mediator *mediator):Colleague(mediator){}
void Send(string message)
{
//通过中介者发送消息
mediator->Send(message,this);
}
void Notify(string message)
{
cout << "同事1得到消息：" << message<<endl;
}
};
class ConcreteColleague2 : public Colleague
{
public:
ConcreteColleague2(Mediator *mediator):Colleague(mediator){}
void Send(string message)
{
//通过中介者发送消息
mediator->Send(message,this);
}
void Notify(string message)
{
cout << "同事2得到消息：" << message<<endl;
}
};

//具体中介者类
class ConcreteMediator : public Mediator
{
private:
ConcreteColleague1 *colleague1;
ConcreteColleague2 *colleague2;
public:
void SetConcreteColleague1(ConcreteColleague1 *colleague1){ this->colleague1 = colleague1;}
void SetConcreteColleague2(ConcreteColleague2 *colleague2){ this->colleague2 = colleague2;}
//重写发送信息的方法，根据对象作出选择判断，通知对象。
void Send(string message,Colleague *colleague)
{
if(colleague == colleague2)
colleague2->Notify(message);
else
colleague1->Notify(message);
}
};

int main()
{
ConcreteMediator m;
ConcreteColleague1 c1(&m);
ConcreteColleague2 c2(&m);

m.SetConcreteColleague1(&c1);
m.SetConcreteColleague2(&c2);

c1.Send("吃过饭了吗？");
c2.Send("没有呢，你打算请客？");

return 1;
}

由于有了Mediator，使得ConcreteColleague1和ConcreteColleague2在发送消息和接收信息时其实是通过中介者完成的，着就减少了它们之间的耦合度了。
下面我们举一个例子，需求是美国和伊拉克之间的对话都是通过联合国安理会作为中介来完成

#include <string>
#include <iostream>
using namespace std;
class Country;
//UniteNations类，抽象中介者,相当于Mediator
class UniteNations
{
public:
virtual void Send(string message,Country *country) = 0;
};
//Country类，抽象同事类,相当于Colleague
class Country
{
protected:
UniteNations *uniteNations;
public:
Country(UniteNations *uniteNations)
{
this->uniteNations = uniteNations;
}
};
//American类，具体同事类,相当于ConcreteColleague1
class America : public Country
{
public:
America(UniteNations *uniteNations):Country(uniteNations){}
void Send(string message)
{
//通过中介者发送消息
uniteNations->Send(message,this);
}
void Notify(string message)
{
cout << "美国获得对方消息：" << message<<endl;
}
};
class Iraq : public Country
{
public:
Iraq(UniteNations *uniteNations):Country(uniteNations){}
void Send(string message)
{
//通过中介者发送消息
uniteNations->Send(message,this);
}
void Notify(string message)
{
cout << "伊拉克获得对方消息：" << message<<endl;
}
};

//具体中介者类，联合国安全理事会
class UniteNationsSecurityConcil : public UniteNations
{
private:
America *colleague1;
Iraq *colleague2;
public:
void SetConcreteColleague1(America *colleague1){ this->colleague1 = colleague1;}
void SetConcreteColleague2(Iraq *colleague2){ this->colleague2 = colleague2;}
//重写发送信息的方法，根据对象作出选择判断，通知对象。
void Send(string message,Country *colleague)
{
if(colleague == colleague2)
colleague2->Notify(message);
else
colleague1->Notify(message);
}
};

int main()
{
UniteNationsSecurityConcil m;
America c1(&m);
Iraq c2(&m);

m.SetConcreteColleague1(&c1);
m.SetConcreteColleague2(&c2);

c1.Send("不准研制核武器，否则发动战争！");
c2.Send("我们没有核武器，也不怕侵略！");

return 1;
}