I. Overview

The mediator pattern encapsulates a series of object interactions with a mediator object. The mediator makes the objects do not need to interact visually, so that they are loosely coupled and can independently change their interactions.

Class diagram

Colleague is an abstract colleague class.

Concrete Colleague is a specific colleague class. Each specific colleague class only knows its own behavior, but does not know the situation of other colleagues. However, they all know the intermediary object and communicate and cooperate with other colleague roles through the intermediary role.

Mediator is an abstract mediator. It defines the interface between the colleague object and the mediator object, which is used to communicate among the colleague roles.

ConcreteMediator is a concrete mediator object and a method to implement Abstract classes. It needs to know all concrete colleague classes, receive messages from specific colleagues and issue commands to specific colleague objects.

3. Examples

class Mediator
{
public:
    void Send(string sMessage,Colleague* pSender);
};

class ConcreteMediator : Mediator
{
public:
    void SetColleague1(ConcreteColleague1* pColleague1);
    void SetColleague2(ConcreteColleague2* pColleague2);

    void Send(string sMessage,Colleague* pSender)
    {
        if(pSender == m_pColleague1)
        {
            m_pColleague2->Notify(sMessage);
        }
        else
        {
            m_pColleague1->Notify(sMessage);
        }
    }

private:
    //Here you need to understand specific colleague class objects rather than abstract colleague class objects
    ConcreteColleague1* m_pColleague1;
    ConcreteColleague2* m_pColleague2;
};

class Colleague
{
public:
    Colleague(Mediator* pMediator)
    {
        m_pMediator = pMediator;
    }
private:
    Mediator* m_pMediator;
};

class ConcreteColleague1 : public Colleague
{
public:
    ConcreteColleague1(Mediator* pMediator)
        :Colleague(pMediator)
    {
        
    }
       
    void Send(string sMessage)
    {
        m_pMediator.Send(sMessage,this);
    }
    
    void Notify(string sMessage)
    {
        cout<<"ConcreteColleague1 receive message:"<<sMessage<<endl;
    }
};

class ConcreteColleague2 : public Colleague
{
public:
    ConcreteColleague2(Mediator* pMediator)
        :Colleague(pMediator)
    {
        
    }
       
    void Send(string sMessage)
    {
        m_pMediator.Send(sMessage,this);
    }
    
    void Notify(string sMessage)
    {
        cout<<"ConcreteColleague2 receive message:"<<sMessage<<endl;
    }
};

void main()
{
    ConcreteMediator* pMediator = new ConcreteMediator();
    ConcreteColleague1* pColleague1 = new ConcreteColleague1(pMediator);
    ConcreteColleague2* pColleague2 = new ConcreteColleague2(pMediator);
    pMediator->SetColleague1(pColleague1);
    pMediator->SetColleague2(pColleague2);
    pColleague1->Send("Anybody here?");
    pColleague2->Send("Where am I?");
}

4. Advantages and disadvantages

The advantage of the mediation mode is to reduce the dependence between classes, turn the original one-to-many dependency into one-to-one dependency, and reduce the coupling between classes by relying only on mediators.

The disadvantage of the intermediary model is that the intermediary will expand greatly and its logic is complex.

V. Intermediary Model and Appearance Model

Appearance pattern abstracts an object subsystem and provides a unified interface. Its protocol is one-way, that is, the facade object requests this subsystem, and vice versa. Instead, Mediator provides collaborative behavior that Colleague objects cannot support, and the protocol is multidirectional.