当前位置：首页 > news >正文

【设计模式】【行为型模式】中介者模式（Mediator）

news 2025/10/31 17:44:04

👋hi，我不是一名外包公司的员工，也不会偷吃茶水间的零食，我的梦想是能写高端CRUD
🔥 2025本人正在沉淀中… 博客更新速度++
👍 欢迎点赞、收藏、关注，跟上我的更新节奏
🎵 当你的天空突然下了大雨，那是我在为你炸乌云

文章目录

一、入门
什么是中介者模式？
为什么要中介者模式？
怎么实现中介者模式？

二、中介者模式在框架源码中的运用
Java 中的 java.util.Timer
Spring 框架中的 ApplicationContext

三、总结
中介者模式的优点
中介者模式的缺点
中介者模式的适用场景

参考

一、入门

什么是中介者模式？

中介者模式（Mediator Pattern）是一种行为设计模式，旨在减少对象之间的直接依赖，通过引入一个中介者对象来协调多个对象之间的交互。这种模式特别适用于对象间存在复杂交互的场景，能够简化系统结构并降低耦合。
中介者模式的核心是封装对象间的交互，避免对象直接相互调用，而是通过中介者进行通信。这样，对象只需与中介者交互，而不需要知道其他对象的存在。

为什么要中介者模式？

假设有一个聊天室系统，多个用户（User）之间可以直接发送消息。如果没有中介者模式，用户之间会直接相互依赖：

class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void sendMessage(String message, User receiver) {
        System.out.println(name + " sends: " + message);
        receiver.receiveMessage(message, this);
    }

    public void receiveMessage(String message, User sender) {
        System.out.println(name + " received from " + sender.name + ": " + message);
    }
}

public class ChatRoomWithoutMediator {
    public static void main(String[] args) {
        User alice = new User("Alice");
        User bob = new User("Bob");
        User charlie = new User("Charlie");

        alice.sendMessage("Hi Bob!", bob);
        bob.sendMessage("Hello Alice!", alice);
        charlie.sendMessage("Hey everyone!", alice); // 需要手动发送给每个人
    }
}

在没有中介者模式的情况下，对象之间通常会直接相互调用和依赖，导致以下问题：

对象间耦合度高：
○ 每个对象都需要知道其他对象的存在，并直接调用它们的方法。
○ 如果对象间的关系复杂，依赖会变得混乱，难以维护。
交互逻辑分散：
○ 对象间的交互逻辑分散在各个对象中，导致代码重复且难以管理。
○ 修改一个对象的逻辑可能会影响其他多个对象。
系统难以扩展：
○ 新增或修改对象时，可能需要修改多个相关对象的代码。
○ 系统的可扩展性和灵活性较差。
难以理解和维护：
○ 对象间的直接依赖关系使得代码难以理解，尤其是在对象数量多、交互复杂的情况下。

怎么实现中介者模式？

在中介者模式中有如下角色：

Mediator（中介者接口）：定义对象间通信的接口。
ConcreteMediator（具体中介者）：实现中介者接口，协调各对象间的交互。
Colleague（同事类）：定义各个对象的接口，每个同事类都知道中介者，并通过中介者与其他对象通信。
ConcreteColleague（具体同事类）：实现同事类接口，与其他对象通过中介者交互。

【案例】聊天室 - 改
在这里插入图片描述
Mediator（中介者接口）：ChatMediator接口

interface ChatMediator {
    void sendMessage(String message, User sender);
    void addUser(User user);
}

ConcreteMediator(具体中介者) ： ChatRoom类

class ChatRoom implements ChatMediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void addUser(User user) {
        users.add(user);
    }

    @Override
    public void sendMessage(String message, User sender) {
        for (User user : users) {
            if (user != sender) { // 不发送给自己
                user.receiveMessage(message);
            }
        }
    }
}

Colleague（同事类）：User类

class User {
    private String name;
    private ChatMediator mediator;

    public User(String name, ChatMediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
        System.out.println(name + " sends: " + message);
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message) {
        System.out.println(name + " received: " + message);
    }
}

测试类

public class ChatRoomWithMediator {
    public static void main(String[] args) {
        ChatMediator chatRoom = new ChatRoom();

        User alice = new User("Alice", chatRoom);
        User bob = new User("Bob", chatRoom);
        User charlie = new User("Charlie", chatRoom);

        chatRoom.addUser(alice);
        chatRoom.addUser(bob);
        chatRoom.addUser(charlie);

        alice.sendMessage("Hi everyone!");
        bob.sendMessage("Hello Alice!");
    }
}

二、中介者模式在框架源码中的运用

Java 中的 java.util.Timer

Timer类可以看作是一个中介者，它负责调度和管理多个TimerTask对象。TimerTask是具体的同事类，它们通过Timer来协调任务的执行。

Timer 作为中介者，负责调度和执行任务。
TimerTask 不需要知道其他任务的存在，只需通过Timer来安排自己的执行。

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer(); // 中介者

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task 1 is running.");
            }
        };

        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task 2 is running.");
            }
        };

        // 通过中介者安排任务
        timer.schedule(task1, 1000); // 1秒后执行
        timer.schedule(task2, 2000); // 2秒后执行
    }
}

Spring 框架中的 ApplicationContext

在 Spring 框架中，ApplicationContext可以看作是一个中介者，它负责管理 Bean 的创建、依赖注入和生命周期。

ApplicationContext 作为中介者，集中管理所有 Bean 的交互。
Bean 之间不需要直接依赖，而是通过 ApplicationContext 获取依赖。

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

class ServiceA {
    public void doSomething() {
        System.out.println("Service A is doing something.");
    }
}

class ServiceB {
    private final ServiceA serviceA;

    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public void doSomething() {
        System.out.println("Service B is doing something.");
        serviceA.doSomething();
    }
}

public class SpringExample {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        ServiceB serviceB = context.getBean(ServiceB.class);
        serviceB.doSomething();
    }
}