1. 中介者模式解析：解耦对象交互的利器
在软件系统开发中，我们经常会遇到多个对象之间相互调用、关系复杂的场景。这种网状结构的对象交互会导致系统难以维护和扩展。中介者模式正是为解决这类问题而生的设计模式。我第一次在电商订单系统中应用这个模式时，成功将原本混乱的订单状态流转逻辑梳理得井井有条。
中介者模式的核心思想是引入一个中介对象来封装一组对象之间的交互。这样对象之间不再直接引用，而是通过中介者进行通信，从而将网状结构变为星型结构。这种解耦带来的好处在实际项目中非常明显：当新增交互关系时，只需修改中介者而不用改动各个具体对象。
2. 中介者模式的核心结构与实现
2.1 模式组成要素
中介者模式包含四个关键角色：
- Mediator（抽象中介者）：定义对象间交互的接口
- ConcreteMediator（具体中介者）：实现抽象中介者接口，协调各对象交互
- Colleague（同事类）：知道其中介者对象，通过中介者与其他同事通信
- ConcreteColleague（具体同事类）：实现同事类接口
java复制// 抽象中介者
interface Mediator {
void register(Colleague colleague);
void relay(Colleague colleague, String message);
}
// 具体中介者
class OrderMediator implements Mediator {
private List<Colleague> colleagues = new ArrayList<>();
@Override
public void register(Colleague colleague) {
colleagues.add(colleague);
colleague.setMediator(this);
}
@Override
public void relay(Colleague sender, String message) {
for(Colleague c : colleagues) {
if(c != sender) {
c.receive(message);
}
}
}
}
// 抽象同事类
abstract class Colleague {
protected Mediator mediator;
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
abstract void receive(String message);
abstract void send();
}
// 具体同事类
class PaymentService extends Colleague {
@Override
void receive(String message) {
System.out.println("支付服务收到：" + message);
}
@Override
void send() {
mediator.relay(this, "支付已完成");
}
}
2.2 典型应用场景
中介者模式特别适合以下场景：
- 对象之间存在复杂的网状引用关系
- 系统需要在不改变对象结构的情况下调整交互方式
- 多个类之间的依赖关系导致系统难以复用
我在实际项目中遇到的一个典型案例是订单状态管理。订单状态变化需要触发库存扣减、物流通知、积分计算等多个服务。如果不使用中介者模式，这些服务之间会形成复杂的调用链，而通过引入订单状态中介者，各服务只需与中介者交互，大大降低了系统复杂度。
3. 中介者模式的深度应用实践
3.1 与观察者模式的结合应用
中介者模式常与观察者模式结合使用，形成更强大的解耦方案。在我的一个IM系统项目中，就采用了这种组合模式：
java复制// 消息中介者同时作为观察者
class MessageMediator implements Mediator, Observer {
private Map<String, List<Colleague>> topicSubscribers = new HashMap<>();
@Override
public void update(Observable o, Object arg) {
// 当被观察对象状态变化时，通知订阅者
String topic = ((Topic)o).getTopicName();
String message = (String)arg;
notifySubscribers(topic, message);
}
private void notifySubscribers(String topic, String message) {
List<Colleague> subscribers = topicSubscribers.get(topic);
if(subscribers != null) {
subscribers.forEach(sub -> sub.receive(message));
}
}
}
这种组合的优点是：
- 中介者不需要维护所有同事类的引用
- 同事类可以动态订阅/取消订阅消息主题
- 系统扩展性更强，新增消息类型不影响现有结构
3.2 性能优化技巧
在中介者处理大量对象交互时，性能可能成为瓶颈。以下是几个优化经验：
- 异步处理：对于非实时性要求的消息，可以采用异步队列方式
java复制class AsyncMediator implements Mediator {
private ExecutorService executor = Executors.newFixedThreadPool(4);
private BlockingQueue<MessageTask> queue = new LinkedBlockingQueue<>();
public AsyncMediator() {
new Thread(this::processQueue).start();
}
private void processQueue() {
while(true) {
try {
MessageTask task = queue.take();
executor.submit(task);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
- 消息过滤：中介者可以根据消息类型进行过滤分发，减少不必要的处理
- 缓存机制：对于频繁交互的消息可以引入缓存，避免重复处理
4. 中介者模式的实践陷阱与规避方案
4.1 常见实现误区
-
中介者过度复杂：中介者类可能变成"上帝对象"，包含过多业务逻辑
- 解决方案：遵循单一职责原则，必要时拆分为多个中介者
-
循环依赖问题：中介者和同事类之间可能形成循环调用
- 解决方案：明确调用方向，通常应该是同事类→中介者→其他同事类
-
性能瓶颈：同步调用的中介者可能成为系统瓶颈
- 解决方案：如3.2节所述，采用异步处理机制
4.2 与其他模式的对比选择
-
与外观模式的区别：
- 外观模式是为一组接口提供统一入口，关注简化接口
- 中介者模式是解耦对象间交互，关注对象间通信
-
与观察者模式的选择：
- 观察者模式适合一对多的发布-订阅场景
- 中介者模式适合多对多的复杂交互场景
-
与代理模式的适用场景：
- 代理模式控制对单个对象的访问
- 中介者模式协调多个对象间的交互
5. 中介者模式在现代框架中的应用实例
5.1 Spring框架中的事件机制
Spring框架的事件发布机制是中介者模式的典型实现：
java复制// 定义事件
class OrderEvent extends ApplicationEvent {
public OrderEvent(Object source) {
super(source);
}
}
// 事件发布者（同事类）
@Service
class OrderService {
@Autowired
private ApplicationEventPublisher publisher;
public void createOrder() {
// 业务逻辑...
publisher.publishEvent(new OrderEvent(this));
}
}
// 事件监听者（同事类）
@Component
class InventoryService {
@EventListener
public void handleOrderEvent(OrderEvent event) {
// 处理订单事件
}
}
在这个实现中：
- ApplicationEventPublisher充当抽象中介者
- Spring容器是具体中介者
- 各Service是同事类
5.2 前端框架中的状态管理
以Vuex为例的状态管理库也是中介者模式的应用：
javascript复制// store（中介者）
const store = new Vuex.Store({
state: { count: 0 },
mutations: {
increment (state) {
state.count++
}
}
})
// 组件A（同事类）
methods: {
increment() {
this.$store.commit('increment')
}
}
// 组件B（同事类）
computed: {
count() {
return this.$store.state.count
}
}
这种架构的优势在于：
- 组件间不直接依赖，通过store交互
- 状态变更可预测且易于追踪
- 便于实现跨组件通信
6. 中介者模式的演进与最佳实践
6.1 分布式系统中的中介者
在微服务架构中，我们可以将中介者模式扩展为：
- API网关：作为服务间通信的中介者
- 消息中间件：如Kafka、RabbitMQ充当消息中介
- 服务网格：如Istio控制服务间通信
java复制// 基于Spring Cloud Gateway的API网关配置
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
.route("inventory-service", r -> r.path("/api/inventory/**")
.uri("lb://inventory-service"))
.route("payment-service", r -> r.path("/api/payment/**")
.filters(f -> f.addRequestHeader("X-Request-ID", UUID.randomUUID().toString()))
.uri("lb://payment-service"))
.build();
}
6.2 领域驱动设计中的中介者
在DDD中，我们可以使用领域事件来实现中介者模式：
java复制// 领域事件
class OrderPaidEvent implements DomainEvent {
private OrderId orderId;
private Payment payment;
// ...
}
// 领域服务（中介者）
class OrderProcessingService {
@Transactional
public void processPayment(Order order, Payment payment) {
order.markAsPaid(payment);
domainEventPublisher.publish(new OrderPaidEvent(order.id(), payment));
}
}
// 事件处理器（同事类）
class InventoryUpdater {
@EventListener
public void handle(OrderPaidEvent event) {
inventoryService.adjustStock(event.orderId(), -1);
}
}
这种实现的优势在于：
- 明确限界上下文之间的交互边界
- 通过事件实现松耦合
- 便于实现事件溯源
在实际项目中使用中介者模式时，我发现最重要的不是模式本身，而是对业务交互关系的准确建模。一个好的中介者应该像交通警察一样，既确保各方有序通行，又不会过度干预每辆车的行驶方式。