设计模式-中介者模式

背景

现在有三个模块，A，B，C，这三个模块之间存在互相调用

使用设计模式之前

package com.design.mode.meditor;

public class Origin {
    public static class ModuleA {

        public void executeModule() {
            System.out.println("模块A开始执行其它模块");
            ModuleB moduleB = new ModuleB();
            ModuleC moduleC = new ModuleC();
            moduleB.execute();
            moduleC.execute();
        }

        public void execute() {
            System.out.println("模块A");
        }
    }

    public static class ModuleB {

        public void executeModule() {
            System.out.println("模块B开始执行其它模块");
            ModuleA moduleA = new ModuleA();
            ModuleC moduleB = new ModuleC();
            moduleB.execute();
            moduleA.execute();
        }

        public void execute() {
            System.out.println("模块B");
        }
    }

    public static class ModuleC {
        public void executeModule() {
            System.out.println("模块C开始执行其它模块");
            ModuleB moduleB = new ModuleB();
            ModuleA moduleA = new ModuleA();
            moduleB.execute();
            moduleA.execute();
        }

        public void execute() {
            System.out.println("模块C");
        }
    }

    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ModuleB moduleB = new ModuleB();
        ModuleC moduleC = new ModuleC();
        moduleA.executeModule();
        moduleB.executeModule();
        moduleC.executeModule();
    }

}

缺点

很明显的可以看到三个模块之间互相依赖，耦合性非常强

 

使用中介者模式

package com.design.mode.meditor;

public class MeditorMode {

    public static class Meditor{
        private void ModuleAInvoke() {
            Origin.ModuleB moduleB = new Origin.ModuleB();
            Origin.ModuleC moduleC = new Origin.ModuleC();
            moduleB.execute();
            moduleC.execute();
        }

        private void ModuleBInvoke() {

            System.out.println("模块B开始执行其它模块");
            Origin.ModuleA moduleA = new Origin.ModuleA();
            Origin.ModuleC moduleB = new Origin.ModuleC();
            moduleB.execute();
            moduleA.execute();
        }

        private void ModuleCInvoke() {

            Origin.ModuleB moduleB = new Origin.ModuleB();
            Origin.ModuleA moduleA = new Origin.ModuleA();
            moduleB.execute();
            moduleA.execute();
        }
    }


    public static class ModuleA {

        public void executeModule() {
            System.out.println("模块A开始执行其它模块");
            meditor.ModuleAInvoke();
        }
        public void execute() {
            System.out.println("模块A");
        }

        private Meditor meditor;

        public ModuleA(Meditor meditor) {
            this.meditor = meditor;
        }
    }

    public static class ModuleB {

        public void executeModule() {
            System.out.println("模块B开始执行其它模块");
            meditor.ModuleBInvoke();
        }

        public void execute() {
            System.out.println("模块B");
        }

        private Meditor meditor;

        public ModuleB(Meditor meditor) {
            this.meditor = meditor;
        }
    }

    public static class ModuleC {

        public void executeModule() {
            System.out.println("模块C开始执行其它模块");
            meditor.ModuleCInvoke();
        }

        public void execute() {
            System.out.println("模块C");
        }

        private Meditor meditor;

        public ModuleC(Meditor meditor) {
            this.meditor = meditor;
        }

    }

    public static void main(String[] args) {
        Meditor meditor = new Meditor();
        ModuleA moduleA = new ModuleA(meditor);
        ModuleB moduleB = new ModuleB(meditor);
        ModuleC moduleC = new ModuleC(meditor);
        moduleA.executeModule();
        moduleB.executeModule();
        moduleC.executeModule();
    }
}

优点：模块之间通过中间者进行通信，进行了解耦，优点类似controller-service-dao这种三层架构