中介者模式

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

Mediator Pattern

Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from refering to each other explicitly, and it lets you vary their interaction independently.

类图

模式的结构与使用

中介者模式的结构中包括四种角色。
+ 中介者（Mediator）：中介者使一个接口，该接口定义了用于同事（Colleague）对象之间进行通信的方法。
+ 具体中介者（Concrete Mediator）：具体中介者是实现中介者接口的类。具体中介者需要包含所有具体同事（Concrete Colleague）的引用，并通过实现中介者接口中的方法来满足具体同事之间的通信请求。
+ 同事（Colleague）：一个接口，规定了具体同事需要实现的方法。
+ 具体同事（Concrete Colleague）：实现同事接口的类。具体同事需要包含具体中介者的引用，一个具体同事需要和其他同事交互时，只需将自己的请求通知给它所包含的具体中介者即可。

简单的例子

同事接口类Colleague.java

package Mediator;

public interface Colleague {
    public void giveMess(String[] mess);
    public void receiverMess(String mess);
    public void setName(String name);
    public String getName();
}

本问题直接需要一个具体中介者ConcreteMediator.java

package Mediator;

public class ConcreteMediator {
    ColleagueA colleagueA;
    ColleagueB colleagueB;
    ColleagueC colleagueC;

    public void registerColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void registerColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    public void registerColleagueC(ColleagueC colleagueC) {
        this.colleagueC = colleagueC;
    }

    public void deliverMess(Colleague colleague, String[] mess) {
        if (colleague == colleagueA) {
            if (mess.length >= 2) {
                colleagueB.receiverMess(colleague.getName() + mess[0]);
                colleagueC.receiverMess(colleague.getName() + mess[1]);
            }
        }
        if (colleague == colleagueB) {
            if (mess.length >= 2) {
                colleagueA.receiverMess(colleague.getName() + mess[0]);
                colleagueC.receiverMess(colleague.getName() + mess[1]);
            }
        }
        if (colleague == colleagueC) {
            if (mess.length >= 2) {
                colleagueA.receiverMess(colleague.getName() + mess[0]);
                colleagueB.receiverMess(colleague.getName() + mess[1]);
            }
        }
    }
}

ConcreteColleague的实现类ColleagueA.java

package Mediator;

public class ColleagueA implements Colleague {

    ConcreteMediator cm;
    String name;

    public ColleagueA(ConcreteMediator cm) {
        this.cm = cm;
        cm.registerColleagueA(this);
    }

    @Override
    public void giveMess(String[] mess) {
        cm.deliverMess(this, mess);
    }

    @Override
    public void receiverMess(String mess) {
        System.out.println(name + "收到的信息");
        System.out.println("\t" + mess);
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }
}

ConcreteColleague的实现类ColleagueB.java

package Mediator;

public class ColleagueB implements Colleague {

    ConcreteMediator cm;
    String name;

    public ColleagueB(ConcreteMediator cm) {
        this.cm = cm;
        cm.registerColleagueB(this);
    }

    @Override
    public void giveMess(String[] mess) {
        cm.deliverMess(this, mess);
    }

    @Override
    public void receiverMess(String mess) {
        System.out.println(name + "收到的信息");
        System.out.println("\t" + mess);
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }
}

ConcreteColleague的实现类ColleagueC.java

package Mediator;

public class ColleagueC implements Colleague {

    ConcreteMediator cm;
    String name;

    public ColleagueC(ConcreteMediator cm) {
        this.cm = cm;
        cm.registerColleagueC(this);
    }

    @Override
    public void giveMess(String[] mess) {
        cm.deliverMess(this, mess);
    }

    @Override
    public void receiverMess(String mess) {
        System.out.println(name + "收到的信息");
        System.out.println("\t" + mess);
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }
}

测试类Application.java

package Mediator;

public class Appication {

    public static void main(String[] args) {
        ConcreteMediator cm = new ConcreteMediator();
        ColleagueA colleagueA = new ColleagueA(cm);
        ColleagueB colleagueB = new ColleagueB(cm);
        ColleagueC colleagueC = new ColleagueC(cm);
        colleagueA.setName("A国");
        colleagueB.setName("B国");
        colleagueC.setName("C国");
        String[] messA = {"要求归还曾抢夺的100斤土豆", "要求归还曾抢夺的20头牛"};
        colleagueA.giveMess(messA);

        String[] messB = {"要求归还曾抢夺的10只公鸡", "要求归还曾抢夺的15匹马"};
        colleagueB.giveMess(messB);

        String[] messC = {"要求归还曾抢夺的300斤小麦", "要求归还曾抢夺的50头驴"};
        colleagueC.giveMess(messC);
    }
}

运行截图

中介者模式的优点

• 可以避免许多的对象为了之间的通信而相互显示引用，否则，不仅系统难于维护，而且也使其他系统难以复用这些对象。
• 可以通过中介者将原本分布于多个对象之间的交互行为集中在一起。当这些对象之间需要改变之间的通信行为时，只需使用一个具体中介者即可，不必修改各个具体同事的代码，即这些同事可被重用。
• 具体中介者使得各个具体同事完全解耦，修改任何一个具体同事的代码不会影响到其他同事。
• 具体中介者集中了同事之间是如何交互的细节，使系统比较清楚地知道整个系统中同事是如何交互的。
• 当一些对象想相互通信，但又无法相互包含对方的引用，那么使用中介者模式就可以使这些对象互相通信。
  注：由于具体中介者集中了同事之间是如何交互的细节，可能使具体具体中介者变得非常复杂，增加了维护的难度。

适用中介者模式的情景

• 许多对象以复杂的方式交，所导致的依赖关系使系统难以理解和维护。
• 一个对象引用其他很多对象，导致难以复用该对象。

下载源码请到

MyGitHub