Java中介者模式详解

中介者模式详解

一、中介者模式概述

中介者模式(Mediator Pattern)是一种行为型设计模式，它通过定义一个中介对象来封装一系列对象之间的交互，使对象之间不需要显式地相互引用，从而降低耦合度。

核心特点

• 集中控制：交互逻辑集中在中介者中
• 解耦对象：对象间不再直接通信
• 简化交互：多对多关系变为一对多
• 协议统一：定义统一的交互接口

二、中介者模式的结构

主要角色

1. Mediator：抽象中介者，定义通信接口
2. ConcreteMediator：具体中介者，协调各同事对象
3. Colleague：抽象同事类
4. ConcreteColleague：具体同事类，通过中介者通信

三、中介者模式的实现

1. 基本实现

// 抽象中介者
public interface ChatMediator {void sendMessage(String msg, User user);void addUser(User user);
}// 具体中介者 - 聊天室
public class ChatRoom implements ChatMediator {private List<User> users;public ChatRoom() {this.users = new ArrayList<>();}public void sendMessage(String msg, User user) {for (User u : users) {if (u != user) {u.receive(msg);}}}public void addUser(User user) {this.users.add(user);}
}// 抽象同事类
public abstract class User {protected ChatMediator mediator;protected String name;public User(ChatMediator med, String name) {this.mediator = med;this.name = name;}public abstract void send(String msg);public abstract void receive(String msg);
}// 具体同事类
public class ChatUser extends User {public ChatUser(ChatMediator med, String name) {super(med, name);}public void send(String msg) {System.out.println(name + " 发送: " + msg);mediator.sendMessage(msg, this);}public void receive(String msg) {System.out.println(name + " 收到: " + msg);}
}// 使用示例
ChatMediator mediator = new ChatRoom();
User user1 = new ChatUser(mediator, "Alice");
User user2 = new ChatUser(mediator, "Bob");
User user3 = new ChatUser(mediator, "Charlie");mediator.addUser(user1);
mediator.addUser(user2);
mediator.addUser(user3);user1.send("大家好！");

2. 更复杂的实现（事件驱动）

// 事件类型
public enum EventType {ALARM, NOTIFICATION, WARNING
}// 事件类
public class SystemEvent {private EventType type;private String message;public SystemEvent(EventType type, String message) {this.type = type;this.message = message;}// getter方法public EventType getType() { return type; }public String getMessage() { return message; }
}// 抽象中介者
public interface SystemMediator {void notify(SystemEvent event, SystemComponent sender);
}// 具体中介者
public class ControlCenter implements SystemMediator {private List<SystemComponent> components = new ArrayList<>();public void register(SystemComponent component) {components.add(component);}public void notify(SystemEvent event, SystemComponent sender) {for (SystemComponent c : components) {if (c != sender) {c.handleEvent(event);}}}
}// 抽象同事类
public abstract class SystemComponent {protected SystemMediator mediator;public SystemComponent(SystemMediator mediator) {this.mediator = mediator;mediator.register(this);}public abstract void handleEvent(SystemEvent event);
}// 具体同事类 - 传感器
public class Sensor extends SystemComponent {public Sensor(SystemMediator mediator) {super(mediator);}public void triggerAlarm() {SystemEvent event = new SystemEvent(EventType.ALARM, "传感器触发警报");mediator.notify(event, this);}public void handleEvent(SystemEvent event) {if (event.getType() == EventType.NOTIFICATION) {System.out.println("传感器收到通知: " + event.getMessage());}}
}

四、中介者模式的应用场景

1. GUI组件交互

// 表单中介者
public class FormMediator {private TextBox nameTextBox;private TextBox emailTextBox;private Button submitButton;private Label errorLabel;public void register(TextBox name, TextBox email, Button submit, Label error) {this.nameTextBox = name;this.emailTextBox = email;this.submitButton = submit;this.errorLabel = error;// 设置事件监听nameTextBox.addChangeListener(e -> validateForm());emailTextBox.addChangeListener(e -> validateForm());}private void validateForm() {boolean isValid = !nameTextBox.getText().isEmpty() && emailTextBox.getText().contains("@");submitButton.setEnabled(isValid);errorLabel.setVisible(!isValid);}
}

2. 航空交通管制系统

// 飞机类
public class Aircraft {private String flightNumber;private AirTrafficControl atc;public Aircraft(String flightNumber, AirTrafficControl atc) {this.flightNumber = flightNumber;this.atc = atc;}public void send(String message) {atc.sendMessage(message, this);}public void receive(String message) {System.out.println(flightNumber + " 收到消息: " + message);}
}// 空中交通管制中介者
public class AirTrafficControl {private List<Aircraft> aircrafts = new ArrayList<>();public void register(Aircraft aircraft) {aircrafts.add(aircraft);}public void sendMessage(String message, Aircraft sender) {for (Aircraft a : aircrafts) {if (a != sender) {a.receive(message);}}}
}

3. 微服务协调

// 服务中介者
public class ServiceMediator {private OrderService orderService;private PaymentService paymentService;private InventoryService inventoryService;public void placeOrder(Order order) {// 协调各个服务if (inventoryService.checkStock(order.getItems())) {PaymentResult result = paymentService.processPayment(order);if (result.isSuccess()) {orderService.createOrder(order);inventoryService.updateStock(order.getItems());}}}
}

五、中介者模式的变体

1. 观察者中介者混合模式

public class HybridMediator implements Mediator, EventListener {private Map<Class<? extends Event>, List<Colleague>> listeners = new HashMap<>();public void subscribe(Class<? extends Event> eventType, Colleague colleague) {listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(colleague);}public void notify(Event event) {List<Colleague> colleagues = listeners.get(event.getClass());if (colleagues != null) {for (Colleague c : colleagues) {c.handle(event);}}}
}

2. 分布式中介者

public class DistributedMediator implements Mediator {private List<RemoteColleague> colleagues = new ArrayList<>();private MessagingService messagingService;public void sendMessage(String message, RemoteColleague sender) {for (RemoteColleague c : colleagues) {if (c != sender) {messagingService.send(c.getAddress(), message);}}}
}

六、中介者模式的优缺点

优点

1. 降低耦合度：对象间不直接依赖
2. 简化交互：多对多变为一对多
3. 集中控制：交互逻辑集中管理
4. 复用性高：可复用中介者处理相似交互

缺点

1. 中介者可能复杂：中介者可能成为上帝对象
2. 性能影响：中介者可能成为瓶颈
3. 过度集中：过度使用可能导致系统僵化

七、最佳实践

1. 合理划分职责：避免中介者承担过多责任
2. 分层设计：复杂系统可使用多层中介者
3. 接口设计：定义清晰的通信协议
4. 性能优化：对高频交互进行优化
5. 结合其他模式：如观察者、命令模式

八、总结

中介者模式是管理复杂交互的有效方案，特别适用于：

• 对象间存在复杂的网状引用关系
• 需要集中控制多个对象间的交互
• 交互逻辑需要复用或统一管理
• 系统需要动态调整交互方式

在实际开发中，中介者模式常见于：

• GUI框架中的组件交互
• 聊天应用中的消息传递
• 分布式系统的协调服务
• 工作流引擎
• 游戏中的角色交互

正确使用中介者模式可以简化系统架构，但需要注意避免中介者过度复杂化。