👋hi，我不是一名外包公司的员工，也不会偷吃茶水间的零食，我的梦想是能写高端CRUD
🔥 2025本人正在沉淀中... 博客更新速度++
👍 欢迎点赞、收藏、关注，跟上我的更新节奏
🎵 当你的天空突然下了大雨，那是我在为你炸乌云
一、入门
什么是中介者模式？
中介者模式（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();
}
}
三、总结
中介者模式的优点
- 降低耦合度：
- 对象之间不再直接依赖，而是通过中介者进行通信。
- 每个对象只需知道中介者，而不需要知道其他对象的存在。
- 集中管理交互逻辑：
- 对象间的交互逻辑集中在中介者中，避免了逻辑分散。
- 修改交互逻辑时，只需修改中介者，而不需要修改各个对象。
- 提高系统的可扩展性：
- 新增对象时，只需修改中介者，而不需要修改现有对象。
- 系统的扩展性和灵活性得到提升。
- 简化代码结构：
- 对象间的依赖关系变得清晰，代码更易于理解和维护。
- 增强可维护性：
- 由于交互逻辑集中在中介者中，调试和维护更加方便。
中介者模式的缺点
- 中介者可能变得复杂：
- 如果对象间交互复杂，中介者可能会变得庞大且难以维护。
- 中介者承担了过多的职责，可能违反单一职责原则。
- 性能瓶颈：
- 所有交互都通过中介者进行，可能导致中介者成为性能瓶颈。
- 过度集中化：
- 中介者集中了所有交互逻辑，可能导致系统过度依赖中介者，难以拆分或重构。
中介者模式的适用场景
- 对象间交互复杂：
- 当多个对象之间存在复杂的交互关系，直接依赖会导致耦合度过高时，适合使用中介者模式。
- 需要集中管理交互逻辑：
- 当对象间的交互逻辑分散在各个对象中，难以维护时，可以通过中介者集中管理。
- 需要解耦对象间的依赖：
- 当对象之间需要解耦，避免直接依赖时，中介者模式是一个很好的选择。
- 适用于事件驱动系统：
- 在事件驱动系统中，中介者可以充当事件分发器，集中管理事件的传递和处理。
- GUI 开发：
- 在 GUI 开发中，中介者模式常用于管理组件间的交互，例如按钮点击、输入框变化等。
- 多对多通信场景：
- 当多个对象需要相互通信，且通信关系复杂时，中介者模式可以简化通信逻辑。
