By

前言

Github：https://github.com/HealerJean

博客：http://blog.healerjean.com

1、Mediator中介者模式

想象一个乱糟糟的开发小组的工作状态，组员之间虽然在一起协同工作，但是意见难以统一，总是相互指挥，导致工作进度滞后。这时候，就需要一个仲裁者。

所有的组员将自己的情况汇报给仲裁者，仲裁者会从团队的整体考虑，然后下达指令。仲裁者负责统一大家的意见。这样，团队的交流过程就变成了组员向仲裁者报告，仲裁者向组员下达指令的形式，而组员之间不再询问和沟通，这就是Mediator模式。

1.1、解释

1.1.1、使用场景

使用的时候，我可以在一些互相调用的场景中使用，有一些先后顺序执行的类可以使用该中介者模式，他们之间互相频繁的调用

1.1.2、缺点

1、如果涉及不好，引入中介者会使程序变的复杂

2、中介者承担过多责任，维护不好会出大事，合理使用回调（如果我们将closeDevice中传入仲裁者，这样又可以回调了）

1.2、示例代码

有3个设备，A设备操作要关闭B和C，通过仲裁者来进行操作，而不是他们之间互相调用，其他的大家也可以自己写

1.2.1、设备接口 Device

public abstract class Device {


    public abstract void openDevice(
        String instruction, 
        AbstractMediator abstractMediator);


    public abstract void closeDevice(String instruction);

}

1.2.1.1、ADevice

public class ADevice extends Device{


    @Override
    public void openDevice(String instruction, AbstractMediator mediator) {
        System.out.println("A设备正在"+instruction);
        mediator.openA(instruction);
    }

    @Override
    public void closeDevice(String instruction) {
        System.out.println("A设备关闭");
    }

}

1.2.1.2、BDevice

public class BDevice extends Device {


    /**
     * 操作该设备
     */
    @Override
    public void openDevice(String instruction, AbstractMediator abstractMediator) {
        abstractMediator.openB(instruction);
    }

    @Override
    public void closeDevice(String instruction) {
        System.out.println("B设备关闭");
    }


}

1.2.1.3、CDevice

public class CDevice extends Device {


    @Override
    public void openDevice(String instruction, AbstractMediator abstractMediator) {
        abstractMediator.openC(instruction);
    }

    @Override
    public void closeDevice(String instruction) {
        System.out.println("C设备关闭");
    }

}

1.2.2、仲裁者、中介者AbstractMediator

public abstract class AbstractMediator {

    /**
     *保留所有设备的引用是为了当接收指令时可以唤醒其他设备的操作
     */
    Device a , b , c;

    public AbstractMediator(Device a, Device b, Device c) {
        super();
        this.a = a;
        this.b = b;
        this.c = c;
    }

 /**
     * 定义操作属性
     */
    public abstract void openA(String instruction);
    public abstract void openB(String instruction);
    public abstract void openC(String instruction);

}

1.2.2.1、仲裁者真正实现类

public class ConcreteAbstractMediator extends AbstractMediator {

    public ConcreteAbstractMediator(Device a, Device b, Device c) {
        super(a, b, c);
    }

    /**
     * 开启A要关闭B和C
     * @param instruction
     */
    @Override
    public void openA(String instruction) {
         b.closeDevice(instruction);
         c.closeDevice(instruction);
    }


    @Override
    public void openB(String instruction) {

    }

    @Override
    public void openC(String instruction) {

    }
}

### 1.2.3、测试

public class Main {

    public static void main(String[] args) {
        Device a = new ADevice();
        Device b = new BDevice();
        Device c = new CDevice();

        //把设备引用都保存在调停者中
        AbstractMediator mediator=new ConcreteAbstractMediator(a , b ,c );

        a.openDevice("开启",mediator);
    }
}


A设备正在开启
B设备关闭
C设备关闭