设计模式之：中介者模式

业务场景

（1）三个模块
（2）模块1调用模块2和模块3；模块2要调用模块1和模块3；模块3要调用模块1和模块2

这个模式，担心的就是系统中各个子系统之前互相之间调用，乱成一团

所以就将系统之间互相调用的逻辑给放到一个所谓的中介者里面去。

每个系统如果要通知别的系统干个什么事儿，直接就是调用中介者，中介者负责去调用别的系统。

中介者这个模式说白了就是要让各个系统之间彻底解耦，不要互相强耦合在一起，互相调用过多，调用关系过于混乱。

互相调用的时候通过一个中间的组件来解耦。

在实际的企业开发中，很少有见到说封装一个所谓的中介者，去让各个模块之间解耦，思考这个模式的本质，让各个模块之间解耦合

最常见的一个方式，就是系统与系统之间，不是走直接的接口调用，而是基于MQ来解耦。

模块A要调用模块B和模块C，模块A发送一条消息到MQ里面去，模块B和模块C去消费这条消息，读到消息之后，知道模块A要调用自己，所以就执行对应的逻辑即可。

常见于系统与系统之间的调用，可以基于MQ消息，异步执行的方式来调用，不需要同步调用和执行

public class MediatorPatternDemo {

    public static void main(String[] args) {
        Mediator mediator = new Mediator();

        ModuleA moduleA = new ModuleA(mediator);
        ModuleB moduleB = new ModuleB(mediator);
        ModuleC moduleC = new ModuleC(mediator);

        moduleA.execute();
        moduleB.execute();
        moduleC.execute();

        /**
         * 好处在哪儿
         * moduleA，只要知道一个中介者就可以了，具体跟其他模块的交互都封装在中介者里面了
         * moduleB，同上
         * moduleC，同上
         * moduleA、B、C之间不再有任何的耦合，不再有复杂的交互关系，互相之间修改不会对对方产生什么影响
         */
    }

    public static class Mediator {

        private ModuleA moduleA;
        private ModuleB moduleB;
        private ModuleC moduleC;

        public ModuleA getModuleA() {
            return moduleA;
        }

        public void setModuleA(ModuleA moduleA) {
            this.moduleA = moduleA;
        }

        public ModuleB getModuleB() {
            return moduleB;
        }

        public void setModuleB(ModuleB moduleB) {
            this.moduleB = moduleB;
        }

        public ModuleC getModuleC() {
            return moduleC;
        }

        public void setModuleC(ModuleC moduleC) {
            this.moduleC = moduleC;
        }

        public void moduleAInvoke() {
            moduleB.execute("模块A通知中介者");
            moduleC.execute("模块A通知中介者");
        }

        public void moduleBInvoke() {
            moduleA.execute("模块B通知中介者");
            moduleC.execute("模块B通知中介者");
        }

        public void moduleCInvoke() {
            moduleA.execute("模块C通知中介者");
            moduleB.execute("模块C通知中介者");
        }

    }

    public static class ModuleA {

        private Mediator mediator;

        public ModuleA(Mediator mediator) {
            this.mediator = mediator;
            this.mediator.setModuleA(this);
        }

        public void execute() {
            mediator.moduleAInvoke();
        }

        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块A的功能");
        }

    }

    public static class ModuleB {

        private Mediator mediator;

        public ModuleB(Mediator mediator) {
            this.mediator = mediator;
            this.mediator.setModuleB(this);
        }

        public void execute() {
            mediator.moduleBInvoke();
        }

        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块B的功能");
        }

    }

    public static class ModuleC {

        private Mediator mediator;

        public ModuleC(Mediator mediator) {
            this.mediator = mediator;
            this.mediator.setModuleC(this);
        }

        public void execute() {
            mediator.moduleCInvoke();
        }

        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块C的功能");
        }

    }

}