小易说IT 小易说IT

Java 中介者模式 (Mediator) 示例代码

 ·  Java

模式思想：用一个中介对象封装一系列对象交互，各对象不需要显式互相引用，将多对多依赖转为一对多，降低耦合。

  • Mediator：中介者抽象接口

  • ConcreteMediator：具体中介者，维护所有同事对象，协调交互

  • Colleague：抽象同事类，持有中介者引用

  • ConcreteColleague：具体同事，只和中介者通信，不直接互相调用

完整可运行代码

// 中介者抽象
interface Mediator {
    void sendMessage(String message, Colleague sender);
}

// 抽象同事类
abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void receive(String message);
}

// 具体同事A
class ColleagueA extends Colleague {
    public ColleagueA(Mediator mediator) {
        super(mediator);
    }

    public void send(String msg) {
        System.out.println("【A发送】：" + msg);
        // 不直接调用B/C，交给中介转发
        mediator.sendMessage(msg, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("【A收到消息】：" + message);
    }
}

// 具体同事B
class ColleagueB extends Colleague {
    public ColleagueB(Mediator mediator) {
        super(mediator);
    }

    public void send(String msg) {
        System.out.println("【B发送】：" + msg);
        mediator.sendMessage(msg, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("【B收到消息】：" + message);
    }
}

// 具体同事C
class ColleagueC extends Colleague {
    public ColleagueC(Mediator mediator) {
        super(mediator);
    }

    public void send(String msg) {
        System.out.println("【C发送】：" + msg);
        mediator.sendMessage(msg, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("【C收到消息】：" + message);
    }
}

// 具体中介者：聊天室中介，转发消息给其他所有人
class ChatRoomMediator implements Mediator {
    private ColleagueA a;
    private ColleagueB b;
    private ColleagueC c;

    // 注入所有同事
    public void setColleagues(ColleagueA a, ColleagueB b, ColleagueC c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public void sendMessage(String message, Colleague sender) {
        // 中介核心逻辑：广播给除发送者以外的同事
        if (sender != a) a.receive(message);
        if (sender != b) b.receive(message);
        if (sender != c) c.receive(message);
    }
}

// 测试客户端
public class MediatorDemo {
    public static void main(String[] args) {
        ChatRoomMediator chatRoom = new ChatRoomMediator();

        ColleagueA a = new ColleagueA(chatRoom);
        ColleagueB b = new ColleagueB(chatRoom);
        ColleagueC c = new ColleagueC(chatRoom);

        chatRoom.setColleagues(a, b, c);

        System.out.println("===== A发消息 =====");
        a.send("大家好，我是A");

        System.out.println("\n===== B发消息 =====");
        b.send("收到A，我是B");

        System.out.println("\n===== C发消息 =====");
        c.send("两位好，C在这里");
    }
}

输出结果

===== A发消息 =====
【A发送】：大家好，我是A
【B收到消息】：大家好，我是A
【C收到消息】：大家好，我是A

===== B发消息 =====
【B发送】：收到A，我是B
【A收到消息】：收到A，我是B
【C收到消息】：收到A，我是B

===== C发消息 =====
【C发送】：两位好，C在这里
【A收到消息】：两位好，C在这里
【B收到消息】：两位好，C在这里

UML 简要说明

          Mediator(interface)
               ↑
      ChatRoomMediator(持有全部Colleague)
     ↙          ↓           ↘
ColleagueA  ColleagueB  ColleagueC
     ↘          ↓           ↙
          Colleague(abstract)

使用场景

  1. 一组对象以复杂多对多方式交互，想解耦；如聊天室、网关、事件总线、UI 组件交互

  2. 想把业务逻辑集中到中介，同事类只负责自身业务

⚠️缺点：中介者会膨胀庞大，所有交互逻辑堆积在这里，中介会变成上帝类。

Spring 实战常见类比

  • DispatcherServlet 就是典型中介者：接收请求，转发给各个 Controller，Controller 之间不直接通信。

本文原创作者：易君召，详见：https://www.yijunzhao.cc/about，转载请注明出处。

原文链接 https://yijunzhao.cc/archives/java-mediator-pattern-example-code

欢迎访问 https://www.yijunzhao.cc/

https://www.yijunzhao.cc/

Java