- Published on
mediator 中介者模式
在实际的企业开发中，很少有见到说封装一个所谓的中介者，去让各个模块之间解耦，思考这个模式的本质，让各个模块之间解耦合。
最最常见的一个方式，就是系统与系统之间，不是走直接的接口调用，而是基于MQ来解耦。录入过模块A要调用模块B和模块C，模块A发送一条消息到MQ里面去，模块B和模块C去消费这条消息，读到消息之后，知道模块A要调用自己，所以就执行对应的逻辑即可。常见于系统与系统之间的调用，可以基于MQ消息，异步执行的方式来调用，不需要同步调用和执行。
可以想象一下，这不就是典型的各个子系统用MQ来解耦么，有些操作，互相直接不是直接调用，消息发送到MQ，通过MQ来解耦。我们在电商系统里也完全有这种场景，到后面我们设计系统的时候给大家分析。我们可以封装一个基于内存队列的异步解耦中介者组件，然后让系统间有些可以异步的操作通过中介者来执行，降低互相调用的复杂度。
模块A将消息发送到一个内存队列中去，其他的模块去内存队列中消费自己感兴趣的消息，来执行对应的操作，用队列替代了中介者，让各个模块之间解耦合，rocketMQ去做。
场景
- 三个模块
- 模块1调用模块2和模块3；模块2要调用模块1和模块3；模块3要调用模块1和模块2
一般模式
package wang.jinggo.basics.zhss.mediator;
/**
* @author: wangyj
* @create: 2021-10-22
* @version: 1.0.0
**/
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的功能");
}
}
}
设计模式
package wang.jinggo.basics.zhss.mediator;
/**
* @author: wangyj
* @create: 2021-10-22
* @version: 1.0.0
**/
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的功能");
}
}
}