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

1.常规

package com.example.demo.pattern.mediator;
/**
 * @author chenchao
 * @date 2021/11/9
 */
public class WithoutMediatorPatternDemo {
    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ModuleB moduleB = new ModuleB();
        ModuleC moduleC = new ModuleC();
        moduleA.execute();  
        moduleB.execute();  
        moduleC.execute();
        // 模块之间有非常复杂的互相之间的跟蜘蛛网一样的调用
        // 问题，每个模块都要去care很多其他的模块，互相之间耦合很严重
        // 后面在修改代码的时候，代码不好改，模块B一旦修改了自己的代码，可能会影响模块A和模块C
    }
    public static class ModuleA {
        public void execute() {
            ModuleB moduleB = new ModuleB();
            ModuleC moduleC = new ModuleC();
            moduleB.execute("模块A");  
            moduleC.execute("模块A");  
        }
        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块A的功能");
        }
    }
    public static class ModuleB {
        public void execute() {
            ModuleA moduleA = new ModuleA();
            ModuleC moduleC = new ModuleC();
            moduleA.execute("模块B");  
            moduleC.execute("模块B");  
        }
        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块B的功能");
        }
    }
    public static class ModuleC {
        public void execute() {
            ModuleA moduleA = new ModuleA();
            ModuleB moduleB = new ModuleB();
            moduleA.execute("模块C");  
            moduleB.execute("模块C");  
        }
        public void execute(String invoker) {
            System.out.println(invoker + "在调用模块C的功能");
        }
    }
}

2.中介者模式

package com.example.demo.pattern.mediator;
/**
 * @author chenchao
 * @date 2021/11/9
 */
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的功能");
        }
    }
}

3.说明

这个模式，担心的就是系统中各个子系统之前互相之间调用，乱成一团。所以就将系统之间互相调用的逻辑给放到一个所谓的中介者里面去。每个系统如果要通知别的系统干个什么事儿，直接就是调用中介者，中介者负责去调用别的系统。

我们来思考一下这个本质，其实说白了，这个模式就是要让各个系统之间彻底解耦，不要互相强耦合在一起，互相调用过多，调用关系过于混乱。互相调用的时候通过一个中间的组件来解耦。

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

最最常见的一个方式，就是系统与系统之间，不是走直接的接口调用，而是基于MQ来解耦。录入过模块A要调用模块B和模块C，模块A发送一条消息到MQ里面去，模块B和模块C去消费这条消息，读到消息之后，知道模块A要调用自己，所以就执行对应的逻辑即可。常见于系统与系统之间的调用，可以基于MQ消息，异步执行的方式来调用，不需要同步调用和执行。

大家想一下，这不就是典型的各个子系统用MQ来解耦么，有些操作，互相直接不是直接调用，消息发送到MQ，通过MQ来解耦。我们在电商系统里也完全有这种场景，到后面我们设计系统的时候给大家分析。我们可以封装一个基于内存队列的异步解耦中介者组件，然后让系统间有些可以异步的操作通过中介者来执行，降低互相调用的复杂度。

模块A将消息发送到一个内存队列中去，其他的模块去内存队列中消费自己感兴趣的消息，来执行对应的操作，用队列替代了中介者，让各个模块之间解耦合，rabbitmq去做

03 筑基_设计模式

11 中介者模式：让互相调用的模块之间解耦合

1.常规

2.中介者模式

3.说明