设计模式 中介者模式

1、mediator.h

#ifndef MEDIATOR_H
#define MEDIATOR_H

#include <iostream>
#include <iostream>
#include <map>
using namespace std;

class User;
class Room //Mediator,中介基类
{
public:
    Room();
    virtual ~Room();
    virtual void Register(User*) = 0;
    virtual void Send(char* pFrom, char* pTo, char* pMsg) = 0;
};

class Chatroom : public Room //ConcreteMediator,中介具体类
{
public:
    Chatroom();
    virtual ~Chatroom();
    void Register(User*);
    void Send(char* pFrom, char* pTo, char* pMsg);
private:
    map<char*, User*> m_mapUsers;
};

class User //用户基类
{
public:
    User(char*);
    virtual ~User();
    void Send(char* pTo, char* pMsg);
    virtual void Receive(char* pFrom, char* pMsg);
    void SetChatroom(Chatroom*);
    friend class Chatroom;
private:
    char* m_pName;
    Chatroom* m_pChatroom;
};

class UserInGroupA : public User //具体组用户类A，与B交互通过ConcreteMediator来实现
{
public:
    UserInGroupA(char*);
    virtual ~UserInGroupA();
    virtual void Receive(char* pFrom, char* pMsg);
};

class UserInGroupB : public User //具体组用户类B，与A交互通过ConcreteMediator来实现
{
public:
    UserInGroupB(char*);
    virtual ~UserInGroupB();
    virtual void Receive(char* pFrom, char* pMsg);
};
#endif // MEDIATOR_H

2、mediator.cpp

#include "mediator.h"

Room::Room(){}

Room::~Room(){}

Chatroom::Chatroom(){}

Chatroom::~Chatroom(){}

void Chatroom::Register(User* pUser)
{
    if(m_mapUsers[pUser->m_pName] == NULL)
    {
        m_mapUsers[pUser->m_pName] = pUser;
    }
    pUser->SetChatroom(this);
}

void Chatroom::Send(char* pFrom, char* pTo, char* pMsg)
{
    User* pUserTo = (User*)m_mapUsers[pTo];
    if(pUserTo != NULL)
    {
        pUserTo->Receive(pFrom, pMsg);
    }
}

User::User(char* pName)
{
    m_pName = pName;
}

User::~User()
{
    if(m_pChatroom != NULL)
    {
        delete m_pChatroom;
        m_pChatroom = NULL;
    }
}

void User::Send(char* pTo, char* pMsg)
{
    m_pChatroom->Send(m_pName, pTo, pMsg);
}

void User::SetChatroom(Chatroom* pChatroom)
{
    m_pChatroom = pChatroom;
}

void User::Receive(char* pFrom, char* pMsg)
{
    cout << pFrom << " to " << this->m_pName << " said:'" << pMsg <<"'"<< endl;
}

UserInGroupA::UserInGroupA(char* pName) : User(pName){}

UserInGroupA::~UserInGroupA(){}

void UserInGroupA::Receive(char* pFrom, char* pMsg)
{
    cout << "UserInGroupA receive->:";
    User::Receive(pFrom, pMsg);
}

UserInGroupB::UserInGroupB(char* pName) : User(pName){}

UserInGroupB::~UserInGroupB(){}

void UserInGroupB::Receive(char* pFrom, char* pMsg)
{
    cout << "UserInGroupB receive->:";
    User::Receive(pFrom, pMsg);
}

3、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

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

动机：
面向对象设计，鼓励将行为分布在各个对象中，这种分布可能导致对象间有很多链接，在最坏的情况下，每个对象都要知道基他的所有对象，
这样，如果有N个对象，则将会有N*(N-1)/2种情况。

理解：
1.Mediator中介者模式，在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，
  如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。使用一个中介对象来管理对象间的关联关系，
  避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化。
2.将多个对象间复杂的关联关系解耦，mediator模式将多个对象间的控制逻辑进行集中管理，变多个对象互相关联为多个对象和
  一个中介者关联，简化了系统的维护，抵御了可能的变化。随着控制逻辑的复杂化，mediator具体对象的实现可能相当复杂。
  这时候可以对mediator对象进行分解处理。Façade模式是解耦系统外到系统内（单向）的对象关联关系；
  mediator模式是解耦系统内各个对象之间（双向）的关联关系。

要点：
1.将系统按功能分割成更小的对象，符合类的最小设计原则.
2.对关联对象的集中控制.
3.减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中任何一个类的修改都会影响到其他类，
  不符合类的设计的开闭原则,而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，
  当其中一个类修改时，可以对其他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4.有利于提高类的重用性.

应用：
1.一组对象以定义良好但是复杂的方式进行通信,产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。

以聊天室的例子说明如下，一个聊天室可以很多成员，成员可以加入不同的讨论组，聊天室就是一个中介，讨论组中的成员通过聊天室发送消息。

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "mediator.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    Chatroom* pChatroom = new Chatroom();

    User* pUserA1 = new UserInGroupA("UserA1");
    User* pUserA2 = new UserInGroupA("UserA2");
    User* pUserB1 = new UserInGroupB("UserB1");

    pChatroom->Register(pUserA1);
    pChatroom->Register(pUserA2);
    pChatroom->Register(pUserB1);

    pUserA1->Send("UserA2", "hello，UserA2");
    pUserA2->Send("UserB1", "hello，UserB1");
    pUserB1->Send("UserA1", "hello，UserA1");

    cout << "=== jhluroom finish _^_ ===" << endl;
    return 0;
}

运行结果：

=== jhluroom start ========

UserInGroupA receive->:UserA1 to UserA2 said:'hello，UserA2'
UserInGroupB receive->:UserA2 to UserB1 said:'hello，UserB1'
UserInGroupA receive->:UserB1 to UserA1 said:'hello，UserA1'

=== jhluroom finish _^_ ===