中介者模式

定义：

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

中介者模式属于行为型模式。

主要解决：

对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

何时使用：

多个类相互耦合，形成了网状结构。

如何解决：

将上述网状结构分离为星型结构。

关键代码：

对象 Colleague 之间的通信封装到一个类中单独处理。

应用实例： 

1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 

2、机场调度系统。

 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。它的作用就是把M(Model,业务逻辑)和V(View,视图)隔离开，协同M和V工作，M运行结果和V代表的视图交互，减少M和V的依赖关系。

优点： 

1、降低了类的复杂度，将一对多转化成了一对一。 

2、各个类之间的解耦。

 3、符合迪米特原则。

缺点：

中介者会庞大，变得复杂难以维护。

使用场景：

 1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 

2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

UML图：

（1）Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。

（2）ConcreteMediator：具体中介者角色，继承于抽象中介者，实现了父类定义的方法，它从具体的同事对象接受消息，向具体同事对象发出命令。需要知道所有具体同事类。

（3）Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。

（4）ConcreteColleague1、ConcreteColleague2：具体同事类角色，继承于抽象同事类，每个具体同事类都知道本身在小范围的行为，而不知道在大范围内的目的。具体同事类只知道自己的行为，而不了解其他同事类的情况。

#include <iostream>
#include <string>

using namespace std;

class Mediator;

class Person
{
public:
    virtual void setMediator(Mediator* mediator){}
    virtual void sendMessage(string msg) = 0;
    virtual void getMessage(string){}
protected:
    Mediator *m_mediator;//依赖于中介
};
class Mediator
{
public:
    virtual void setHost(Person* p) = 0;
    virtual void setClient(Person* p) = 0;
    virtual void sendMsg(Person* p,string msg){}
};
class HostPerson:public Person
{
public:
    HostPerson(){}
    void setMediator(Mediator* mediator)
    {
        m_mediator = mediator;
    }
    void sendMessage(string msg)
    {
        m_mediator->sendMsg(this,msg);
    }
    void getMessage(string msg)
    {
        cout << "房东收到消息！" <<endl;
    }

};

class ClientPerson:public Person
{
public:
    ClientPerson(){}
    void setMediator(Mediator* mediator)
    {
        m_mediator = mediator;
    }
    void sendMessage(string msg)
    {
        m_mediator->sendMsg(this,msg);
    }
    void getMessage(string msg)
    {
        cout << "客户收到消息！" <<endl;
    }

};

class HouseMediator:public Mediator
{
public:
    HouseMediator(){}
    void setHost(Person* p)
    {
        m_host = p;
    }
    void setClient(Person* p)
    {
        m_client = p;
    }
    void sendMsg(Person* p,string msg)
    {
        if(p == m_host)
        {
            m_client->getMessage(msg);
        }
        else
        {
            m_host->getMessage(msg);
        }
    }
private:
    Person* m_host;
    Person* m_client;
};


int main()
{
    HouseMediator *mediator = new HouseMediator();
    HostPerson *host = new HostPerson();
    ClientPerson *client = new ClientPerson();

    host->setMediator(mediator);
    client->setMediator(mediator);

    mediator->setClient(client);
    mediator->setHost(host);

    client->sendMessage("我要租房子!");
    host->sendMessage("有房子要出租!");

    return 0;
}