设计模式系统回顾（16）中介者模式-优快云博客

本文链接：https://blog.youkuaiyun.com/wangwangliqing/article/details/122878096

本文探讨了如何通过使用中介者模式来降低服务之间的耦合，以抽象服务类和服务A、B为例，介绍了如何通过注册中心进行间接调用，以及这种模式在复杂引用和依赖场景中的优势与局限。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目的：解耦，降低通信复杂性
比如：微服务互相之间不用相互调用，而是通过注册中心调用，避免服务间的互相依赖
以下是一个注册中心的例子

//抽象服务类
public abstract class AbstractService {
    protected AbstractMediator mediator;//这个就是中介者对象，后面会建立这个对象

    public AbstractService(AbstractMediator mediator) {
        this.mediator = mediator;
    }

    public abstract void doSomething();
}

public class ServiceA extends AbstractService {

    public ServiceA(AbstractMediator mediator) {
        super(mediator);
    }

    @Override
    public void doSomething() {//这个方法是服务 A 自己干的活
        System.out.println("I'm Service A");
    }

    public void callB(){//服务A中需要调用服务 B 的方法
        this.doSomething();//做点自己的事情先，这个可以不用，实际开发中看需求
        System.out.println("调用Service B");
        mediator.callServiceB();//通过中介者调用服务B的方法
    }
}

public class ServiceB extends AbstractService {
    public ServiceB(AbstractMediator mediator) {
        super(mediator);
    }

    @Override
    public void doSomething() {//这个方法是服务 B 自己干的活
        System.out.println("I'm Service B");
    }

    public void callA(){//服务B中需要调用服务A的方法
        this.doSomething();
        System.out.println("调用Service A");//做点自己的事情先，这个可以不用，实际开发中看需求
        mediator.callServiceA();//通过中介者调用服务 A 的方法
    }
}
//中介者对象
public abstract class AbstractMediator {
    protected AbstractService serviceA;//持有服务 A
    protected AbstractService serviceB;//持有服务 B

    public void setServiceA(AbstractService serviceA) {
        this.serviceA = serviceA;
    }

    public void setServiceB(AbstractService serviceB) {
        this.serviceB = serviceB;
    }

    /**
    * 下面这两个方法也一样，一般每个微服务都需要对应一个方法
    **/
    public abstract void callServiceA();//调用服务 A 方法

    public abstract void callServiceB();//调用服务 B 方法
}

public class RegisterCenter extends AbstractMediator{
    @Override
    public void callServiceA() {//调用服务 A
        super.serviceA.doSomething();

    }

    @Override
    public void callServiceB() {//调用服务 B
        super.serviceB.doSomething();
    }
}

public class TestMediator {
    public static void main(String[] args) {
        AbstractMediator registerCenter = new RegisterCenter();//构建一个中介者对象
        //将每个对象初始化进中介者对象
        ServiceA serviceA = new ServiceA(registerCenter);
        ServiceB serviceB = new ServiceB(registerCenter);

        registerCenter.setServiceA(serviceA);
        registerCenter.setServiceB(serviceB);

        serviceA.callB();//服务 A 调用服务 B，实际上服务 A 内部是通过中介者调用服务 B，A 和 B 本身并不直接打交道
        System.out.println("--------------------");
        serviceB.callA();
    }
}

适用场景
对象存在非常复杂的引用关系,互相依赖的时候
优点
减少依赖，降低耦合
缺点
当服务过多时，中介者会过于庞大，难以维护