Java设计模式之中介者模式：从入门到架构级实践

听闻风很好吃2025-04-15 8:14

一、什么是中介者模式？

中介者模式（Mediator Pattern）是一种行为型设计模式，其核心思想是通过引入一个中介对象来封装多个对象之间的交互关系。这种模式将原本复杂的网状通信结构转换为星型结构，类似于现实生活中的机场塔台调度系统：所有飞机不再需要与其他飞机直接通信，而是统一通过塔台协调飞行路线和起降顺序。

模式特点扩展：

  • 通信标准化：定义统一的交互协议

  • 状态管理：中介者可以维护全局状态

  • 事务协调：支持跨对象的事务操作

  • 动态路由：根据运行时条件决定消息流向

二、为什么需要中介者模式？------深入痛点分析

2.1 复杂系统通信问题

在大型软件系统中，当对象间存在以下通信特征时，系统复杂度会急剧上升：

  • 多对多依赖：一个对象需要与多个对象交互

  • 交叉调用：对象间的调用形成循环依赖

  • 状态同步：需要保持多个对象状态的一致性

  • 条件路由：消息传递需要基于特定业务规则

典型案例：电商订单系统

  • 订单创建需要联动库存、支付、物流等多个模块

  • 库存锁定失败需要回滚支付操作

  • 物流状态变更需要通知用户和商家

2.2 传统实现的问题

java 复制代码 
// 没有中介者时的典型代码结构
class Order {
    private InventoryService inventory;
    private PaymentService payment;
    private LogisticsService logistics;

    public void createOrder() {
        if(inventory.lockStock()) {
            if(payment.processPayment()) {
                logistics.scheduleDelivery();
            } else {
                inventory.releaseStock();
            }
        }
    }
}

存在的问题：

  1. 业务逻辑分散在各个对象中

  2. 新增模块需要修改现有代码

  3. 错误处理逻辑复杂

  4. 难以实现事务一致性

三、模式结构深度解析

3.1 核心角色扩展说明

1. 抽象中介者（Mediator）------ 通信协议设计
java 复制代码 
public interface OrderMediator {
    // 注册组件
    void register(String componentName, OrderComponent component);
    
    // 事件通知方法
    void notifyEvent(OrderComponent sender, OrderEvent event);
    
    // 事务补偿接口
    void rollback(OrderTransaction transaction);
    
    // 状态查询接口
    OrderSystemState getCurrentState();
}
2. 具体中介者（ConcreteMediator）------ 业务规则实现
java 复制代码 
public class OrderCoordinator implements OrderMediator {
    private Map<String, OrderComponent> components = new ConcurrentHashMap<>();
    private OrderSystemState systemState = new OrderSystemState();
    private TransactionLog transactionLog = new TransactionLog();

    @Override
    public void notifyEvent(OrderComponent sender, OrderEvent event) {
        // 使用策略模式处理不同事件类型
        EventHandler handler = EventHandlerFactory.getHandler(event.getType());
        handler.handle(this, sender, event);
    }

    // 实现事务补偿
    @Override
    public void rollback(OrderTransaction transaction) {
        transaction.getSteps().reverse().forEach(step -> {
            OrderComponent component = components.get(step.getComponentName());
            component.compensate(step.getParameters());
        });
    }
}
3. 抽象同事类（Colleague）------ 组件标准化
java 复制代码 
public abstract class OrderComponent {
    protected OrderMediator mediator;
    protected String componentName;
    protected ComponentHealth healthStatus;

    public OrderComponent(String name, OrderMediator mediator) {
        this.componentName = name;
        this.mediator = mediator;
        mediator.register(name, this);
    }

    // 统一的生命周期接口
    public abstract void initialize();
    public abstract void shutdown();
    
    // 事务操作接口
    public abstract boolean execute(OrderCommand command);
    public abstract void compensate(Map<String, Object> params);
    
    // 健康检查
    public ComponentHealth checkHealth() {
        return healthStatus;
    }
}

四、代码实现：智能家居控制系统（增强版）

4.1 场景扩展需求

在原有基础上增加：

  • 设备离线处理机制

  • 场景模式支持（离家模式、睡眠模式）

  • 能耗监控与报警

  • 异步事件处理

4.2 增强版中介者实现

java 复制代码 
public class SmartHomeHub implements SmartHomeMediator {
    private Map<String, Device> devices = new ConcurrentHashMap<>();
    private ExecutorService asyncExecutor = Executors.newFixedThreadPool(4);
    private EnergyMonitor energyMonitor = new EnergyMonitor();
    private AlertSystem alertSystem = new AlertSystem();

    @Override
    public void notify(Device sender, DeviceEvent event) {
        // 异步处理事件
        asyncExecutor.submit(() -> {
            try {
                processEvent(sender, event);
            } catch (Exception e) {
                handleError(sender, event, e);
            }
        });
    }

    private void processEvent(Device sender, DeviceEvent event) {
        // 记录设备活动
        energyMonitor.recordActivity(sender.getId(), event.getType());
        
        // 根据事件类型路由处理
        switch (event.getType()) {
            case "MOTION_DETECTED":
                handleMotionEvent(sender, event);
                break;
            case "TEMPERATURE_CHANGE":
                handleTemperatureEvent(sender, event);
                break;
            case "DEVICE_OFFLINE":
                handleOfflineEvent(sender, event);
                break;
            // 其他事件类型...
        }
    }

    private void handleOfflineEvent(Device sender, DeviceEvent event) {
        // 启动设备健康检查
        if (!checkDeviceHealth(sender)) {
            alertSystem.triggerAlert("设备离线警告: " + sender.getId());
            // 自动切换到备用设备
            failoverToBackup(sender);
        }
    }

    // 其他处理方法...
}

4.3 设备类的增强实现

java 复制代码 
public class SmartThermostat extends Device {
    private TemperatureSchedule schedule;
    private boolean isEnergySavingMode;

    @Override
    public void execute(DeviceCommand command) {
        switch (command.getType()) {
            case "SET_TEMPERATURE":
                setTemperature((Double) command.getParam("value"));
                break;
            case "ENERGY_SAVING_MODE":
                enableEnergySaving((Boolean) command.getParam("enable"));
                break;
        }
    }

    private void setTemperature(double temp) {
        // 实际温度控制逻辑
        System.out.println("Setting temperature to: " + temp);
        // 触发温度变化事件
        mediator.notify(this, new DeviceEvent("TEMPERATURE_CHANGED", 
            Map.of("newTemp", temp, "oldTemp", currentTemp)));
    }

    @Override
    public void handleEvent(DeviceEvent event) {
        if ("ENERGY_ALERT".equals(event.getType())) {
            enableEnergySaving(true);
        }
    }
}

五、架构级应用实践（深度扩展）

5.1 微服务API网关的进阶实现

增强功能需求：

  • 动态路由配置

  • 服务熔断降级

  • 请求/响应转换

  • 分布式链路追踪

java 复制代码 
public class AdvancedApiGateway implements Mediator {
    private ServiceRegistry registry;
    private CircuitBreakerManager circuitBreakers;
    private RequestTransformer transformer;
    private TracingContext tracer;

    public Response handleRequest(Request request) {
        // 1. 链路追踪初始化
        Span span = tracer.startSpan("gateway.handle");
        
        try {
            // 2. 协议转换
            InternalRequest internalReq = transformer.transform(request);
            
            // 3. 服务发现
            ServiceEndpoint endpoint = registry.discover(internalReq.getService());
            
            // 4. 熔断检查
            if (circuitBreakers.isOpen(endpoint)) {
                return fallbackResponse(internalReq);
            }
            
            // 5. 负载均衡选择实例
            ServiceInstance instance = loadBalancer.select(endpoint);
            
            // 6. 请求转发
            Response response = instance.call(internalReq);
            
            // 7. 响应转换
            return transformer.transform(response);
        } catch (Exception e) {
            span.recordException(e);
            throw e;
        } finally {
            span.end();
        }
    }
    
    // 服务注册回调接口
    public void onServiceRegistered(ServiceEvent event) {
        // 动态更新路由表
        registry.update(event.getService(), event.getInstances());
        // 初始化新的熔断器
        circuitBreakers.createIfAbsent(event.getService());
    }
}

5.2 事件驱动架构中的消息中间件优化

高级特性实现：

  • 消息持久化保证

  • 死信队列处理

  • 消息优先级支持

  • 事务消息支持

java 复制代码 
public class ReliableMessageBroker implements Mediator {
    private MessageStore messageStore;
    private PriorityDispatcher dispatcher;
    private DeadLetterQueue dlq;
    
    public void publish(String topic, Message message) {
        // 事务管理
        Transaction tx = messageStore.beginTransaction();
        try {
            // 1. 持久化存储
            messageStore.store(topic, message, tx);
            
            // 2. 分发到订阅者
            List<Consumer> consumers = dispatcher.getSubscribers(topic);
            for (Consumer consumer : consumers) {
                dispatchToConsumer(consumer, message);
            }
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
            dlq.store(topic, message, e);
        }
    }
    
    private void dispatchToConsumer(Consumer consumer, Message message) {
        try {
            if (consumer.getPriority() > message.getPriority()) {
                // 低优先级消息延迟处理
                delayQueue.put(message, 5000);
                return;
            }
            
            consumer.consume(message);
        } catch (ConsumerException e) {
            if (e.isRetryable()) {
                retryLater(message);
            } else {
                dlq.store(message, e);
            }
        }
    }
}

六、模式进阶与变体（实战扩展）

6.1 分布式Saga事务协调器实现

java 复制代码 
public class SagaMediator implements Mediator {
    private Map<String, SagaParticipant> participants = new HashMap<>();
    private SagaLogStore logStore = new SagaLogStore();
    
    public void coordinate(Saga saga) {
        SagaContext context = new SagaContext();
        try {
            for (SagaStep step : saga.getSteps()) {
                SagaParticipant participant = participants.get(step.getService());
                
                // 记录操作日志
                logStore.logStepStart(step);
                
                // 执行正向操作
                boolean success = participant.execute(step.getAction(), context);
                
                if (!success) {
                    throw new SagaAbortException("Step failed: " + step);
                }
                
                // 记录补偿点
                context.addCompensationPoint(step);
            }
            logStore.logSagaComplete(saga);
        } catch (Exception e) {
            logStore.logSagaAbort(saga, e);
            compensate(context);
        }
    }
    
    private void compensate(SagaContext context) {
        context.getCompensationPoints().reverse().forEach(step -> {
            SagaParticipant participant = participants.get(step.getService());
            try {
                participant.compensate(step.getAction(), context);
            } catch (Exception e) {
                // 记录补偿失败
                logStore.logCompensationFailure(step, e);
            }
        });
    }
}

6.2 中介者与CQRS模式的结合

java 复制代码 
public class CqrsMediator implements Mediator {
    private CommandBus commandBus;
    private QueryBus queryBus;
    private EventPublisher eventPublisher;
    
    public <T> T execute(Command<T> command) {
        // 1. 命令校验
        validateCommand(command);
        
        // 2. 命令路由
        CommandHandler<T> handler = commandBus.findHandler(command);
        
        // 3. 执行命令
        T result = handler.handle(command);
        
        // 4. 发布领域事件
        List<DomainEvent> events = handler.getGeneratedEvents();
        eventPublisher.publish(events);
        
        return result;
    }
    
    public <T> T query(Query<T> query) {
        QueryHandler<T> handler = queryBus.findHandler(query);
        return handler.handle(query);
    }
}

七、注意事项与最佳实践（深度总结）

7.1 性能优化关键点

  1. 异步处理：

    java 复制代码 
    // 使用CompletableFuture实现异步中介
public class AsyncMediator {
    private Executor executor = ForkJoinPool.commonPool();
    
    public <T> CompletableFuture<T> mediateAsync(MediationTask<T> task) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return processTask(task);
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        }, executor);
    }
}

  2. 批量处理优化：

    java 复制代码 
    public void batchNotify(List<Notification> notifications) {
    Map<String, List<Notification>> grouped = notifications.stream()
        .collect(Collectors.groupingBy(Notification::getTargetType));
    
    grouped.forEach((type, list) -> {
        BatchProcessor processor = processorRegistry.getProcessor(type);
        processor.processBatch(list);
    });
}

7.2 可靠性设计要点

  1. 事务一致性：

    • 实现两阶段提交协议

    • 使用补偿事务模式

    • 记录详细操作日志

  2. 错误恢复机制：

    java 复制代码 
    public class RetryMediator implements Mediator {
    private static final int MAX_RETRIES = 3;
    
    public void sendWithRetry(Message message) {
        int attempts = 0;
        while (attempts < MAX_RETRIES) {
            try {
                doSend(message);
                return;
            } catch (NetworkException e) {
                attempts++;
                waitForRetry(attempts);
            }
        }
        throw new SendFailedException("Max retries exceeded");
    }
}

7.3 测试策略建议

  1. 中介者单元测试：

    java 复制代码 
    @Test
void testTemperatureEventHandling() {
    // 初始化
    SmartHomeHub hub = new SmartHomeHub();
    TemperatureSensor sensor = new TemperatureSensor("sensor1", hub);
    SmartThermostat thermostat = new SmartThermostat("thermo1", hub);
    
    // 触发事件
    sensor.detectTemperatureChange(25.0);
    
    // 验证结果
    assertThat(thermostat.getCurrentTemp()).isEqualTo(25.0);
    assertThat(hub.getEnergyUsage()).isGreaterThan(0);
}

  2. 混沌测试场景：

    • 随机断开设备连接

    • 模拟高延迟响应

    • 注入错误消息

    • 测试事务回滚机制

八、总结：模式的选择与演进

8.1 中介者模式 vs 其他模式

模式 适用场景 关注点
中介者 复杂对象交互 集中控制通信
观察者 一对多依赖 事件通知
外观模式 简化子系统访问 统一入口
代理模式 访问控制 对象间接访问

8.2 架构演进建议

  1. 初期阶段：在局部复杂交互处引入简单中介者

  2. 中期扩展：逐步抽象为通用协调框架

  3. 成熟阶段：支持插件化扩展和动态配置

  4. 云原生演进：演变为Service Mesh的Sidecar模式

8.3 未来发展方向

  1. AI驱动的智能路由：使用机器学习优化消息路径

  2. 区块链协调器：基于智能合约的分布式中介

  3. 边缘计算协调：跨边缘节点的协同中介

  4. 量子计算适配：设计量子友好的协调算法

通过本文的深度扩展，我们不仅掌握了中介者模式的基础用法，更深入探讨了其在复杂系统架构中的高级应用场景。在实际项目中，建议根据具体需求灵活运用模式的变体和优化策略，同时注意平衡模式的收益与复杂度成本。中介者模式的价值在分布式系统日益复杂的今天愈发重要，是构建可维护、可扩展系统的重要工具之一。

相关推荐
铁弹神侯6 分钟前
Maven相关名词及相关配置
java·maven
会飞的皮卡丘EI20 分钟前
关于Blade框架对数字类型的null值转为-1问题
java·spring boot
雷渊22 分钟前
如何保证数据库和Es的数据一致性？
java·后端·面试
fjkxyl23 分钟前
Spring的启动流程
java·后端·spring
极客先躯25 分钟前
高级java每日一道面试题-2025年4月06日-微服务篇[Nacos篇]-如何诊断和解决Nacos中的常见问题？
java·开发语言·微服务
东锋1.333 分钟前
Spring AI 发布了它的 1.0.0 版本的第七个里程碑（M7）
java·人工智能·spring
liwulin05061 小时前
【JAVAFX】自定义FXML 文件存放的位置以及使用
java
2401_890665861 小时前
免费送源码：Java+ssm+MySQL 基于PHP在线考试系统的设计与实现 计算机毕业设计原创定制
java·hadoop·spring boot·python·mysql·spring cloud·php
胎粉仔1 小时前
Swift —— delegate 设计模式
开发语言·设计模式·swift
逸风尊者1 小时前
开发可掌握的知识：基于事件驱动实现状态机
java
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04Scipy||第三章 线性代数 (scipy.linalg)05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07C#/.NET/.NET Core技术前沿周刊 | 第 34 期（2025年4.7-4.13）08汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10ZNS SSD垃圾回收优化方案解读-1