中介者模式（行为型模式）

7.中介者模式

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

7.1 组成结构

抽象中介者（Mediator）：定义统一的接口，用于各同事角色之间的通信；

具体中介者（ConcreteMediator）：从具体的同事对象接收消息，向具体同事对象发出命令，协调各同事间的协作；

抽象同事类（Colleague）：每一个同事对象均需要依赖中介者角色，与其他同事间通信时，交由中介者进行转发协作；

具体同事类（ConcreteColleague）：负责实现自发行为（Self-Method），转发依赖方法（Dep-Method）交由中介者进行协调；

7.2 场景设计

模拟同事A和同事B之间的相互通信，uml类图如下

7.3 实现

抽象中介者

public abstract class Mediator {
    //放入需要联系的成员类
    protected ColleagueA colleagueA;
    protected ColleagueB colleagueB;

    //成员类的get set
    public ColleagueA getColleagueA() {
        return colleagueA;
    }

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

    public ColleagueB getColleagueB() {
        return colleagueB;
    }

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

    //与同事A通信
    public abstract void sendMessageToColleagueA(String message);
    //与同事B通信
    public abstract void sendMessageToColleagueB(String message);

}

具体中介者

public class ConcreteMediator extends  Mediator{

    //与A成员建立连接
    @Override
    public void sendMessageToColleagueA(String message) {
        //调用同事A的接收消息方法
        super.colleagueA.receiveMessage(message);
    }

    //与B成员建立连接
    @Override
    public void sendMessageToColleagueB(String message) {
        //调用同事B的接收消息方法
        super.colleagueB.receiveMessage(message);
    }
}

抽象同事类

public abstract class Colleague {

    //聚合中介者,用于同事间的通信
    protected Mediator mediator;

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

具体同事类

//同事A
public class ColleagueA extends Colleague{

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


    public void selfMethod(){
        System.out.println("成员A：我是成员A");
    }

    public void receiveMessage(String message){
        System.out.println("成员A收到了 "+message);
    }

    //成员A和成员A进行沟通，但是都调用中介者类
    public void sendMessageToColleagueB(String message){
        super.mediator.sendMessageToColleagueB(message);
    }
}

//同事B
public class ColleagueB extends Colleague{

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

    public void selfMethod(){
        System.out.println("成员B：我是成员B");
    }

    public void receiveMessage(String message){
        System.out.println("成员B收到了 "+message);
    }

    //成员A和成员B进行沟通A，但是都调用中介者类
    public void sendMessageToColleagueA(String message){
        super.mediator.sendMessageToColleagueA(message);
    }
}

//测试类

public class Client {

    public static void main(String[] args) {
    	//创建中介者
        Mediator mediator=new ConcreteMediator();

        //创建同事A和B
        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);

        //中介者设置A和B对象
        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        colleagueA.selfMethod();
        colleagueA.sendMessageToColleagueB("来自成员A");

        colleagueB.selfMethod();
        colleagueB.sendMessageToColleagueA("来自成员B");


    }
}

7.4 优缺点分析

优点：

• 松散耦合

  中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。

• 集中控制交互

  多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了，当然如果是已经做好的系统，那么就扩展中介者对象，而各个同事类不需要做修改。

• 一对多关联转变为一对一的关联

  没有使用中介者模式的时候，同事对象之间的关系通常是一对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对一，这会让对象的关系更容易理解和实现。

缺点：

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

7.5 使用场景

• 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。