C++中介者模式(18)

中介者模式是一种行为设计模式， 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作

该模式让你将对象间的所有关系抽取成为一个单独的类， 以使对于特定组件的修改工作独立于其他组件，由于所有组件间关系都被包含在中介者中， 因此你无需修改组件就能方便地新建中介者类以定义新的组件合作方式。一般来说，大型的软件在开发的过程中会使用模块化的开发方式。但是无论模块之间如何独立，总是会有需要模块间通信的时候，如果模块有很多，且每个模块都向外提供了唯一的接收消息的接口，那么一个模块如果需要与其他所有模块通信，则需要记录其他所有模块的通信接口，同理每个模块都要记录所有与自己相关联的模块的通信接口。首先这就是一件很冗余并降低开发效率的事情，其次，一旦有一天，某个模块修改了自己所提供的通信接口，或者增加了一个新模块，尤其是后者，在公司项目发展过程中是很正常的事情。那么所有模块关于其他模块通信接口的记录可能都需要修改或增加，这在拥有庞大模块数量的项目中，是很恐怖的事情，此时可以考虑中介者模式

1.抽象一个中介者类：定义对象到中介者对象的接口

2.提供一个具体中介者类：实现抽象接口，并且实现关联类数据处理

3.提供一个关联类(同事类)的抽象父类 ：多个关联类之间的交互操作的抽象

4.提供一个或多个具体的关联类(同事类)：实现抽象，通过中介者类完成操作

//三平台通信
#include 
#include 
using namespace std;
enum class Message {
    ATW_MESSAGE,  //移动端到Win
    ATM_MESSAGE,  //移动端到Mac
    WTM_MESSAGE,  // Mac到Win
};
class AbstractModule;
//提供转发接口
class AbstractMediator {
   public:
    virtual void Transmit(Message message, AbstractModule* pm) = 0;
};
class AbstractModule {
   public:
    AbstractModule(AbstractMediator* pM) : pM(pM) {}
    void SendMessage(Message message) { pM->Transmit(message, this); }
    virtual void AcceptMessage(Message message) = 0;

   protected:
    AbstractMediator* pM;
};
class App : public AbstractModule {
   public:
    App(AbstractMediator* pM) : AbstractModule(pM) {}
    void AcceptMessage(Message message) {
        switch (message) {
            case Message::ATM_MESSAGE:
                cout << "App to Mac" << endl;
                break;
            case Message::ATW_MESSAGE:
                cout << "App to Win" << endl;
                break;
        }
    }
};
class Win : public AbstractModule {
   public:
    Win(AbstractMediator* pM) : AbstractModule(pM) {}
    void AcceptMessage(Message message) {
        switch (message) {
            case Message::WTM_MESSAGE:
                cout << "Win to Mac" << endl;
                break;
            case Message::ATW_MESSAGE:
                cout << "App to Win" << endl;
                break;
        }
    }
};
class Mac : public AbstractModule {
   public:
    Mac(AbstractMediator* pM) : AbstractModule(pM) {}
    void AcceptMessage(Message message) {
        switch (message) {
            case Message::WTM_MESSAGE:
                cout << "Win to Mac" << endl;
                break;
            case Message::ATM_MESSAGE:
                cout << "App to Mac" << endl;
                break;
        }
    }
};
//中介者实现类
class ConcreteMediator : public AbstractMediator {
   public:
    void Transmit(Message message, AbstractModule* pM) {
        switch (message) {
            case Message::ATM_MESSAGE: {
                //能通过dynamic_cast转换为不为NULL的指针,可确认指针指向的子类类型
                App* app = dynamic_cast(pM);
                if (NULL != app) {
                    m_mac->AcceptMessage(message);
                } else {
                    app->AcceptMessage(message);
                }
                break;
            }
            case Message::ATW_MESSAGE: {
                App* app = dynamic_cast(pM);
                if (NULL != app) {
                    m_win->AcceptMessage(message);
                } else {
                    app->AcceptMessage(message);
                }
                break;
            }
            case Message::WTM_MESSAGE: {
                Win* win = dynamic_cast(pM);
                if (NULL != win) {
                    m_mac->AcceptMessage(message);
                } else {
                    win->AcceptMessage(message);
                }
                break;
            }
        }
    }
    void SetModuleApp(AbstractModule* app) { this->m_app = app; }
    void SetModuleWin(AbstractModule* win) { this->m_win = win; }
    void SetModuleMac(AbstractModule* mac) { this->m_mac = mac; }

   private:
    AbstractModule* m_app = nullptr;
    AbstractModule* m_win = nullptr;
    AbstractModule* m_mac = nullptr;
};

int main() {
    AbstractMediator* pM = new ConcreteMediator;

    //指定中介者
    AbstractModule* app = new App(pM);
    AbstractModule* win = new Win(pM);
    AbstractModule* mac = new Mac(pM);

    //为中介者设定模块
    ConcreteMediator* pC = dynamic_cast(pM);
    pC->SetModuleApp(app);
    pC->SetModuleWin(win);
    pC->SetModuleMac(mac);

    //模块间通信
    app->SendMessage(Message::ATM_MESSAGE);
    app->SendMessage(Message::ATW_MESSAGE);
    win->SendMessage(Message::WTM_MESSAGE);

    return 0;
}

优点

• 单一职责原则: 你可以将多个组件间的交流抽取到同一位置， 使其更易于理解和维护

• 开闭原则: 你无需修改实际组件就能增加新的中介者

• 你可以减轻应用中多个组件间的耦合情况

• 你可以更方便地复用各个组件

缺点

• 一段时间后， 中介者可能会演化成为上帝对象