MEDIATOR 中介者模式（行为模式）

介绍

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

参与者

• Mediator: 抽象中介者。定义了同事对象到中介者对象之间的接口。
• ConcreteMediator: 具体中介者。实现抽象中介者的方法，它需要知道所有的具体同事类，同时需要从具体的同事类那里接收信息，并且向具体的同事类发送信息。
• Colleague: 抽象同事类。
• ConcreteColleague: 具体同事类。每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。

实现代码

enum{
    Widget_A,
    Widget_B,
};
class Widget;
class Meadiator{
public:
    virtual void showMsg(std::string msg,Widget *meadiator) = 0;
};
class Widget{
public:
    Widget(int id_,Meadiator *meadiator1)
    {
        id = id_;
        meadiator = meadiator1;
    }
    virtual void showMe(std::string) = 0;
    int getId()
    {
        return id;
    }
public:
    Meadiator *meadiator;
    int id;
};
class WidgetA:public Widget{
public:
    WidgetA(int id,Meadiator *meadiator1):Widget(id,meadiator1)
    {
    }
    void showMe(std::string msg) override
    {
        std::cout<<"A: "<<msg<<std::endl;
    }
    void showMsg(std::string msg)
    {
        meadiator->showMsg(msg,this);
    }
};

lass WidgetB:public Widget{
public:
    WidgetB(int id,Meadiator *meadiator1):Widget(id,meadiator1)
    {

    }
    void showMe(std::string msg) override
    {
        std::cout<<"B: "<<msg<<std::endl;
    }
    void showMsg(std::string msg)
    {
        meadiator->showMsg(msg,this);
    }
};
class ConcreteMeadiator: public  Meadiator{
public:
    void SetWidgetA(WidgetA *widgetA1)
    {
        widgetA = widgetA1;
    }
    void SetWidgetB(WidgetB *widgetB1)
    {
        widgetB = widgetB1;
    }
    void showMsg(std::string msg,Widget *widget) override
    {
        if(widget->getId() == Widget_A)
        {
            widgetA->showMe(msg);
        }else if(widget->getId() == Widget_B)
        {
            widgetB->showMe(msg);
        }
    }
private:
    WidgetA *widgetA;
    WidgetB *widgetB;
};

int main()
{
    ConcreteMeadiator meadiator;
    auto *widgetA = new WidgetA(Widget_A,&meadiator);
    auto *widgetB = new WidgetB(Widget_B,&meadiator);
    meadiator.SetWidgetA(widgetA);
    meadiator.SetWidgetB(widgetB);
    widgetA->showMsg("你好啊！");
    widgetB->showMsg("我很好！");
}

输出结果

A: 你好啊！
B: 我很好！

特点

• 简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类解耦，使系统成为松耦合系统。
• 减少了子类的生成。
• 可以减少各同事类的设计与实现。
• 由于中介者对象封装了系统中对象之间的相互关系，导致其变得非常复杂，使得系统维护比较困难。

参考

• https://www.cnblogs.com/chenssy/p/3348520.html