两种语言实现设计模式（C++和Java）（十八：中介者模式）

中介者（Mediator）模式的定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

中介者模式是一种对象行为型模式，其主要优点如下。

1. 降低了对象之间的耦合性，使得对象易于独立地被复用。
2. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

其主要缺点是：当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护。

UML:

以中介者实现同事间相互传递消息为例。

C++实现

#include <string>
#include <iostream>

class Colleague;

class Mediator
{
public:
    virtual void send(std::string  msg, Colleague * p) = 0;
};

class Colleague
{
protected:
    Mediator * m_mediator;
public:
    Colleague(Mediator * p)
    {
        m_mediator = p;
    }
    virtual void send(std::string msg) = 0;
    virtual void notify(std::string msg) = 0;
};

class ConcreteColleague_0 : public Colleague
{
public:
    ConcreteColleague_0(Mediator * p) : Colleague(p) {}
    void send(std::string msg)
    {
        m_mediator->send(msg, this);
    }
    void notify(std::string msg)
    {
        std::cout << "Colleague_0 收到了消息：" << msg << std::endl;
    }
};

class ConcreteColleague_1 : public Colleague
{
public:
    ConcreteColleague_1(Mediator * p) : Colleague(p) {}
    void send(std::string msg)
    {
        m_mediator->send(msg, this);
    }
    void notify(std::string msg)
    {
        std::cout << "Colleague_1 收到了消息：" << msg << std::endl;
    }
};

class ConcreteMediator : public Mediator
{
private:
    // 这里也可以是一个列表
    Colleague * m_p1;
    Colleague * m_p2;
public:
    void addColleague(Colleague * p1, Colleague * p2)
    {
        m_p1 = p1;
        m_p2 = p2;
    }
    void send(std::string msg, Colleague * p)
    {
        // 这里接受来自一个同事发过来的消息，具体应该给谁要根据需求来
        // 这里知识一个很简单的应用。比如该类总可以是有两个队列。
        // 一个队列是客户，一个队列是客服
        if (p == m_p1)
            m_p2->notify(msg);
        else
            m_p1->notify(msg);    
    }
};

int main()
{
    using namespace std;
    // 中介者模式
    ConcreteMediator * p = new ConcreteMediator();
    Colleague * pCol1 = new ConcreteColleague_0(p);
    Colleague * pCol2 = new ConcreteColleague_1(p);
    p->addColleague(pCol1, pCol2);
    pCol1->send("你下班了吗？");
    pCol2->send("没呢，你呢？");
    delete pCol1;
    delete pCol2;
    delete p;
    return 0;
}

Java实现：

public interface Mediator {
    void send(String message, Colleague colleague);
}

public abstract class Colleague {

    protected Mediator mediator;

    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

    public abstract void send(String message);

    abstract public void notify(String message);

}

public class Colleague1 extends Colleague {

    public Colleague1(Mediator mediator){
        super(mediator);
    }

    public void send(String message){
        mediator.send(message, this);
    }

    public void notify(String message){
        System.out.println("Colleague1 received " + message);
    }
}

public class Colleague2 extends Colleague {

    public Colleague2(Mediator mediator){
        super(mediator);
    }

    public void send(String message){
        mediator.send(message, this);
    }

    public void notify(String message){
        System.out.println("Colleague2 received " + message);
    }
}

public class ConcreteMediator implements Mediator {

    private Colleague colleague1;

    private Colleague colleague2;

    public void addColleague(Colleague colleague1, Colleague colleague2){
        this.colleague1 = colleague1;
        this.colleague2 = colleague2;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleague1){
            colleague2.notify(message);
        }else if(colleague == colleague2){
            colleague1.notify(message);
        }
    }
}

public class Main {

    public static void main(String[] args) {
        ConcreteMediator concreteMediator = new ConcreteMediator();
        Colleague1 colleague1 = new Colleague1(concreteMediator);
        Colleague2 colleague2 = new Colleague2(concreteMediator);
        concreteMediator.addColleague(colleague1, colleague2);
        colleague1.send("下班了吗");
        colleague2.send("没呢");
    }
}