设计模式-中介者模式详解

最新推荐文章于 2025-11-24 14:10:54 发布
原创 最新推荐文章于 2025-11-24 14:10:54 发布 · 956 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #中介者模式

中介者模式详解

目录

  1. 中介者模式简介
  2. 核心流程
  3. 重难点分析
  4. Spring中的源码分析
  5. 具体使用场景
  6. 面试高频点
  7. 使用总结

中介者模式简介

定义

中介者模式（Mediator Pattern）是一种行为型设计模式，它用一个中介对象来封装一系列对象之间的交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

核心思想

  • 解耦对象交互：通过中介者解耦对象之间的直接依赖关系
  • 集中控制：将对象间的交互逻辑集中到中介者中
  • 简化通信：简化对象之间的通信方式
  • 易于维护：交互逻辑的修改只需要修改中介者

模式结构

  • Mediator（抽象中介者）：定义同事对象到中介者对象的接口
  • ConcreteMediator（具体中介者）：实现抽象中介者，协调各同事对象的交互关系
  • Colleague（抽象同事类）：定义各同事对象的公有接口
  • ConcreteColleague（具体同事类）：实现抽象同事类，通过中介者与其他同事对象通信

核心流程

中介者模式流程图

消息处理
同事对象层次
中介者层次
消息接收
消息解析
消息路由
消息转发
抽象同事类
具体同事A
具体同事B
具体同事C
抽象中介者接口
具体中介者实现
同事对象注册表
客户端
创建中介者
创建同事对象
注册同事对象到中介者
同事对象发送消息
中介者接收消息
中介者处理消息
中介者转发消息给目标同事
目标同事接收消息
目标同事处理消息
返回处理结果

基本实现流程

1. 定义抽象中介者
// 抽象中介者
public abstract class Mediator {
    protected List<Colleague> colleagues = new ArrayList<>();
  
    public void register(Colleague colleague) {
        colleagues.add(colleague);
        colleague.setMediator(this);
    }
  
    public void unregister(Colleague colleague) {
        colleagues.remove(colleague);
        colleague.setMediator(null);
    }
  
    public abstract void notify(Colleague sender, String message);
    public abstract void notify(Colleague sender, String message, Colleague target);
}
2. 定义抽象同事类
// 抽象同事类
public abstract class Colleague {
    protected Mediator mediator;
    protected String name;
  
    public Colleague(String name) {
        this.name = name;
    }
  
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
  
    public String getName() {
        return name;
    }
  
    public abstract void send(String message);
    public abstract void send(String message, Colleague target);
    public abstract void receive(String message, Colleague sender);
}
3. 实现具体中介者
// 具体中介者
public class ConcreteMediator extends Mediator {
    @Override
    public void notify(Colleague sender, String message) {
        System.out.println("中介者转发消息: " + sender.getName() + " -> " + message);
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receive(message, sender);
            }
        }
    }
  
    @Override
    public void notify(Colleague sender, String message, Colleague target) {
        System.out.println("中介者转发消息: " + sender.getName() + " -> " + target.getName() + " : " + message);
        if (colleagues.contains(target)) {
            target.receive(message, sender);
        }
    }
}
4. 实现具体同事类
// 具体同事类A
public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(String name) {
        super(name);
    }
  
    @Override
    public void send(String message) {
        System.out.println(name + " 发送广播消息: " + message);
        mediator.notify(this, message);
    }
  
    @Override
    public void send(String message, Colleague target) {
        System.out.println(name + " 发送私聊消息给 " + target.getName() + ": " + message);
        mediator.notify(this, message, target);
    }
  
    @Override
    public void receive(String message, Colleague sender) {
        System.out.println(name + " 收到来自 " + sender.getName() + " 的消息: " + message);
    }
}

// 具体同事类B
public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(String name) {
        super(name);
    }
  
    @Override
    public void send(String message) {
        System.out.println(name + " 发送广播消息: " + message);
        mediator.notify(this, message);
    }
  
    @Override
    public void send(String message, Colleague target) {
        System.out.println(name + " 发送私聊消息给 " + target.getName() + ": " + message);
        mediator.notify(this, message, target);
    }
  
    @Override
    public void receive(String message, Colleague sender) {
        System.out.println(name + " 收到来自 " + sender.getName() + " 的消息: " + message);
    }
}
5. 客户端使用
public class Client {
    public static void main(String[] args) {
        // 创建中介者
        Mediator mediator = new ConcreteMediator();
      
        // 创建同事对象
        Colleague colleagueA = new ConcreteColleagueA("同事A");
        Colleague colleagueB = new ConcreteColleagueB("同事B");
      
        // 注册同事对象到中介者
        mediator.register(colleagueA);
        mediator.register(colleagueB);
      
        // 发送消息
        colleagueA.send("大家好，我是同事A");
        colleagueB.send("你好，我是同事B");
        colleagueA.send("你好", colleagueB);
    }
}

重难点分析

重难点1：中介者的复杂度管理

问题描述

随着同事对象数量的增加，中介者可能变得过于复杂，难以维护。

解决方案
// 分层中介者模式
public abstract class BaseMediator {
    protected Map<String, Colleague> colleagues = new HashMap<>();
  
    public void register(String key, Colleague colleague) {
        colleagues.put(key, colleague);
        colleague.setMediator(this);
    }
  
    public Colleague getColleague(String key) {
        return colleagues.get(key);
    }
  
    public abstract void notify(String senderKey, String message);
    public abstract void notify(String senderKey, String message, String targetKey);
}

// 具体中介者实现
public class ChatMediator extends BaseMediator {
    @Override
    public void notify(String senderKey, String message) {
        Colleague sender = getColleague(senderKey);
        if (sender != null) {
            System.out.println("广播消息: " + sender.getName() + " -> " + message);
            for (Colleague colleague : colleagues.values()) {
                if (colleague != sender) {
                    colleague.receive(message, sender);
                }
            }
        }
    }
  
    @Override
    public void notify(String senderKey, String message, String targetKey) {
        Colleague sender = getColleague(senderKey);
        Colleague target = getColleague(targetKey);
        if (sender != null && target != null) {
            System.out.println("私聊消息: " + sender.getName() + " -> " + target.getName() + " : " + message);
            target.receive(message, sender);
        }
    }
}

// 使用策略模式的中介者
public class StrategyMediator extends BaseMediator {
    private Map<String, MessageStrategy> strategies = new HashMap<>();
  
    public void addStrategy(String messageType, MessageStrategy strategy) {
        strategies.put(messageType, strategy);
    }
  
    @Override
    public void notify(String senderKey, String message) {
        Colleague sender = getColleague(senderKey);
        if (sender != null) {
            String messageType = extractMessageType(message);
            MessageStrategy strategy = strategies.get(messageType);
            if (strategy != null) {
                strategy.handleMessage(sender, message, colleagues);
            } else {
                // 默认处理
                defaultHandleMessage(sender, message);
            }
        }
    }
  
    private String extractMessageType(String message) {
        // 根据消息内容提取类型
        if (message.startsWith("@")) {
            return "PRIVATE";
        } else if (message.startsWith("#")) {
            return "GROUP";
        }
        return "BROADCAST";
    }
  
    private void defaultHandleMessage(Colleague sender, String message) {
        System.out.println("默认处理: " + sender.getName() + " -> " + message);
    }
}

重难点2：中介者的性能优化

问题描述

中介者可能成为性能瓶颈，特别是在高并发场景下。

解决方案
// 异步中介者
public class AsyncMediator extends BaseMediator {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    private final BlockingQueue<MessageTask> messageQueue = new LinkedBlockingQueue<>();
  
    public AsyncMediator() {
        // 启动消息处理线程
        executor.submit(new MessageProcessor());
    }
  
    @Override
    public void notify(String senderKey, String message) {
        messageQueue.offer(new MessageTask(senderKey, message, null));
    }
  
    @Override
    public void notify(String senderKey, String message, String targetKey) {
        messageQueue.offer(new MessageTask(senderKey, message, targetKey));
    }
  
    private class MessageProcessor implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    MessageTask task = messageQueue.take();
                    processMessage(task);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
    }
  
    private void processMessage(MessageTask task) {
        Colleague sender = getColleague(task.getSenderKey());
        if (sender != null) {
            if (task.getTargetKey() != null) {
                Colleague target = getColleague(task.getTargetKey());
                if (target != null) {
                    target.receive(task.getMessage(), sender);
                }
            } else {
                for (Colleague colleague : colleagues.values()) {
                    if (colleague != sender) {
                        colleague.receive(task.getMessage(), sender);
                    }
                }
            }
        }
    }
  
    public void shutdown() {
        executor.shutdown();
    }
}

// 消息任务类
public class MessageTask {
    private final String senderKey;
    private final String message;
    private final String targetKey;
  
    public MessageTask(String senderKey, String message, String targetKey) {
        this.senderKey = senderKey;
        this.message = message;
        this.targetKey = targetKey;
    }
  
    // getter方法
    public String getSenderKey() { return senderKey; }
    public String getMessage() { return message; }
    public String getTargetKey() { return targetKey; }
}

重难点3：中介者的扩展性

问题描述

如何让中介者模式具有良好的扩展性，支持新的同事对象类型。

解决方案
// 可扩展的中介者
public class ExtensibleMediator extends BaseMediator {
    private final Map<Class<?>, List<Colleague>> colleaguesByType = new HashMap<>();
    private final Map<String, MediatorPlugin> plugins = new HashMap<>();
  
    @Override
    public void register(String key, Colleague colleague) {
        super.register(key, colleague);
      
        // 按类型分组
        Class<?> colleagueType = colleague.getClass();
        colleaguesByType.computeIfAbsent(colleagueType, k -> new ArrayList<>()).add(colleague);
      
        // 通知插件
        for (MediatorPlugin plugin : plugins.values()) {
            plugin.onColleagueRegistered(colleague);
        }
    }
  
    public void addPlugin(String name, MediatorPlugin plugin) {
        plugins.put(name, plugin);
        plugin.initialize(this);
    }
  
    public void removePlugin(String name) {
        MediatorPlugin plugin = plugins.remove(name);
        if (plugin != null) {
            plugin.destroy();
        }
    }
  
    public <T extends Colleague> List<T> getColleaguesByType(Class<T> type) {
        List<Colleague> colleagues = colleaguesByType.get(type);
        if (colleagues != null) {
            return colleagues.stream()
                    .map(type::cast)
                    .collect(Collectors.toList());
        }
        return Collections.emptyList();
    }
}

// 中介者插件接口
public interface MediatorPlugin {
    void initialize(ExtensibleMediator mediator);
    void onColleagueRegistered(Colleague colleague);
    void onMessageSent(Colleague sender, String message, Colleague target);
    void destroy();
}

// 日志插件
public class LoggingPlugin implements MediatorPlugin {
    private ExtensibleMediator mediator;
  
    @Override
    public void initialize(ExtensibleMediator mediator) {
        this.mediator = mediator;
    }
  
    @Override
    public void onColleagueRegistered(Colleague colleague) {
        System.out.println("同事注册: " + colleague.getName());
    }
  
    @Override
    public void onMessageSent(Colleague sender, String message, Colleague target) {
        System.out.println("消息发送: " + sender.getName() + " -> " + 
                         (target != null ? target.getName() : "所有人") + " : " + message);
    }
  
    @Override
    public void destroy() {
        System.out.println("日志插件销毁");
    }
}

重难点4：中介者的测试

问题描述

如何对中介者模式进行单元测试，确保交互逻辑的正确性。

解决方案
// 可测试的中介者
public class TestableMediator extends BaseMediator {
    private final List<MessageEvent> messageEvents = new ArrayList<>();
  
    @Override
    public void notify(String senderKey, String message) {
        Colleague sender = getColleague(senderKey);
        if (sender != null) {
            messageEvents.add(new MessageEvent(sender, message, null, MessageType.BROADCAST));
          
            for (Colleague colleague : colleagues.values()) {
                if (colleague != sender) {
                    colleague.receive(message, sender);
                }
            }
        }
    }
  
    @Override
    public void notify(String senderKey, String message, String targetKey) {
        Colleague sender = getColleague(senderKey);
        Colleague target = getColleague(targetKey);
        if (sender != null && target != null) {
            messageEvents.add(new MessageEvent(sender, message, target, MessageType.PRIVATE));
            target.receive(message, sender);
        }
    }
  
    public List<MessageEvent> getMessageEvents() {
        return new ArrayList<>(messageEvents);
    }
  
    public void clearMessageEvents() {
        messageEvents.clear();
    }
}

// 消息事件类
public class MessageEvent {
    private final Colleague sender;
    private final String message;
    private final Colleague target;
    private final MessageType type;
    private final long timestamp;
  
    public MessageEvent(Colleague sender, String message, Colleague target, MessageType type) {
        this.sender = sender;
        this.message = message;
        this.target = target;
        this.type = type;
        this.timestamp = System.currentTimeMillis();
    }
  
    // getter方法
    public Colleague getSender() { return sender; }
    public String getMessage() { return message; }
    public Colleague getTarget() { return target; }
    public MessageType getType() { return type; }
    public long getTimestamp() { return timestamp; }
}

// 消息类型枚举
public enum MessageType {
    BROADCAST, PRIVATE, GROUP
}

// 单元测试
public class MediatorTest {
    @Test
    public void testBroadcastMessage() {
        TestableMediator mediator = new TestableMediator();
        Colleague colleagueA = new ConcreteColleagueA("A");
        Colleague colleagueB = new ConcreteColleagueB("B");
      
        mediator.register("A", colleagueA);
        mediator.register("B", colleagueB);
      
        colleagueA.send("Hello");
      
        List<MessageEvent> events = mediator.getMessageEvents();
        assertEquals(1, events.size());
        assertEquals("A", events.get(0).getSender().getName());
        assertEquals("Hello", events.get(0).getMessage());
        assertEquals(MessageType.BROADCAST, events.get(0).getType());
    }
  
    @Test
    public void testPrivateMessage() {
        TestableMediator mediator = new TestableMediator();
        Colleague colleagueA = new ConcreteColleagueA("A");
        Colleague colleagueB = new ConcreteColleagueB("B");
      
        mediator.register("A", colleagueA);
        mediator.register("B", colleagueB);
      
        colleagueA.send("Hello", colleagueB);
      
        List<MessageEvent> events = mediator.getMessageEvents();
        assertEquals(1, events.size());
        assertEquals("A", events.get(0).getSender().getName());
        assertEquals("B", events.get(0).getTarget().getName());
        assertEquals("Hello", events.get(0).getMessage());
        assertEquals(MessageType.PRIVATE, events.get(0).getType());
    }
}

Spring中的源码分析

Spring的ApplicationContext作为中介者

// ApplicationContext接口
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
  
    String getId();
    String getApplicationName();
    String getDisplayName();
    long getStartupDate();
    ApplicationContext getParent();
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
    BeanFactory getParentBeanFactory();
    boolean containsLocalBean(String name);
    String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
    void publishEvent(ApplicationEvent event);
    void publishEvent(Object event);
}

Spring的ApplicationEventPublisher

// ApplicationEventPublisher接口
@FunctionalInterface
public interface ApplicationEventPublisher {
    default void publishEvent(ApplicationEvent event) {
        publishEvent((Object) event);
    }
  
    void publishEvent(Object event);
}

// AbstractApplicationContext中的实现
public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
  
    private ApplicationEventMulticaster applicationEventMulticaster;
  
    @Override
    public void publishEvent(ApplicationEvent event) {
        publishEvent(event, null);
    }
  
    @Override
    public void publishEvent(Object event) {
        publishEvent(event, null);
    }
  
    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");
      
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        } else {
            applicationEvent = new PayloadApplicationEvent<>(this, event);
        }
      
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        } else {
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
        }
      
        if (this.parent != null) {
            if (this.parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            } else {
                this.parent.publishEvent(event);
            }
        }
    }
}

Spring的ApplicationEventMulticaster

// ApplicationEventMulticaster接口
public interface ApplicationEventMulticaster {
    void addApplicationListener(ApplicationListener<?> listener);
    void addApplicationListenerBean(String listenerBeanName);
    void removeApplicationListener(ApplicationListener<?> listener);
    void removeApplicationListenerBean(String listenerBeanName);
    void removeAllListeners();
    void multicastEvent(ApplicationEvent event);
    void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}

// SimpleApplicationEventMulticaster实现
public class SimpleApplicationEventMulticaster implements ApplicationEventMulticaster {
  
    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
      
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            } else {
                invokeListener(listener, event);
            }
        }
    }
  
    @SuppressWarnings({"rawtypes", "unchecked"})
    private void invokeListener(ApplicationListener listener, ApplicationEvent event) {
        ErrorHandler errorHandler = getErrorHandler();
        if (errorHandler != null) {
            try {
                listener.onApplicationEvent(event);
            } catch (Throwable err) {
                errorHandler.handleError(err);
            }
        } else {
            listener.onApplicationEvent(event);
        }
    }
}

Spring的ApplicationListener

// ApplicationListener接口
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

// 使用示例
@Component
public class UserEventListener implements ApplicationListener<UserRegisteredEvent> {
  
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        System.out.println("用户注册事件: " + event.getUsername());
        // 处理用户注册逻辑
    }
}

// 事件类
public class UserRegisteredEvent extends ApplicationEvent {
    private final String username;
    private final String email;
  
    public UserRegisteredEvent(Object source, String username, String email) {
        super(source);
        this.username = username;
        this.email = email;
    }
  
    public String getUsername() { return username; }
    public String getEmail() { return email; }
}

具体使用场景

1. 聊天室系统

// 聊天室中介者
public class ChatRoomMediator {
    private final Map<String, User> users = new HashMap<>();
    private final List<ChatMessage> messages = new ArrayList<>();
  
    public void addUser(User user) {
        users.put(user.getId(), user);
        user.setMediator(this);
        broadcastSystemMessage(user.getName() + " 加入了聊天室");
    }
  
    public void removeUser(String userId) {
        User user = users.remove(userId);
        if (user != null) {
            user.setMediator(null);
            broadcastSystemMessage(user.getName() + " 离开了聊天室");
        }
    }
  
    public void sendMessage(String senderId, String message) {
        User sender = users.get(senderId);
        if (sender != null) {
            ChatMessage chatMessage = new ChatMessage(sender, message, System.currentTimeMillis());
            messages.add(chatMessage);
            broadcastMessage(chatMessage);
        }
    }
  
    public void sendPrivateMessage(String senderId, String receiverId, String message) {
        User sender = users.get(senderId);
        User receiver = users.get(receiverId);
        if (sender != null && receiver != null) {
            ChatMessage chatMessage = new ChatMessage(sender, message, System.currentTimeMillis());
            receiver.receiveMessage(chatMessage);
        }
    }
  
    private void broadcastMessage(ChatMessage message) {
        for (User user : users.values()) {
            if (user != message.getSender()) {
                user.receiveMessage(message);
            }
        }
    }
  
    private void broadcastSystemMessage(String message) {
        ChatMessage systemMessage = new ChatMessage(null, "[系统] " + message, System.currentTimeMillis());
        for (User user : users.values()) {
            user.receiveMessage(systemMessage);
        }
    }
}

// 用户类
public class User {
    private final String id;
    private final String name;
    private ChatRoomMediator mediator;
  
    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }
  
    public void setMediator(ChatRoomMediator mediator) {
        this.mediator = mediator;
    }
  
    public void sendMessage(String message) {
        if (mediator != null) {
            mediator.sendMessage(id, message);
        }
    }
  
    public void sendPrivateMessage(String receiverId, String message) {
        if (mediator != null) {
            mediator.sendPrivateMessage(id, receiverId, message);
        }
    }
  
    public void receiveMessage(ChatMessage message) {
        System.out.println(name + " 收到消息: " + message.getContent());
    }
  
    // getter方法
    public String getId() { return id; }
    public String getName() { return name; }
}

// 聊天消息类
public class ChatMessage {
    private final User sender;
    private final String content;
    private final long timestamp;
  
    public ChatMessage(User sender, String content, long timestamp) {
        this.sender = sender;
        this.content = content;
        this.timestamp = timestamp;
    }
  
    // getter方法
    public User getSender() { return sender; }
    public String getContent() { return content; }
    public long getTimestamp() { return timestamp; }
}

2. 飞机控制系统

// 飞机控制中介者
public class AirTrafficControlMediator {
    private final Map<String, Aircraft> aircrafts = new HashMap<>();
    private final List<Runway> runways = new ArrayList<>();
    private final List<Gate> gates = new ArrayList<>();
  
    public void registerAircraft(Aircraft aircraft) {
        aircrafts.put(aircraft.getId(), aircraft);
        aircraft.setMediator(this);
    }
  
    public void requestLanding(String aircraftId) {
        Aircraft aircraft = aircrafts.get(aircraftId);
        if (aircraft != null) {
            Runway availableRunway = findAvailableRunway();
            if (availableRunway != null) {
                availableRunway.setOccupied(true);
                aircraft.land(availableRunway);
                System.out.println("飞机 " + aircraftId + " 被分配到跑道 " + availableRunway.getId());
            } else {
                aircraft.waitForRunway();
                System.out.println("飞机 " + aircraftId + " 需要等待可用跑道");
            }
        }
    }
  
    public void requestTakeoff(String aircraftId) {
        Aircraft aircraft = aircrafts.get(aircraftId);
        if (aircraft != null) {
            Runway availableRunway = findAvailableRunway();
            if (availableRunway != null) {
                availableRunway.setOccupied(true);
                aircraft.takeoff(availableRunway);
                System.out.println("飞机 " + aircraftId + " 从跑道 " + availableRunway.getId() + " 起飞");
            } else {
                aircraft.waitForRunway();
                System.out.println("飞机 " + aircraftId + " 需要等待可用跑道");
            }
        }
    }
  
    public void requestGate(String aircraftId) {
        Aircraft aircraft = aircrafts.get(aircraftId);
        if (aircraft != null) {
            Gate availableGate = findAvailableGate();
            if (availableGate != null) {
                availableGate.setOccupied(true);
                aircraft.park(availableGate);
                System.out.println("飞机 " + aircraftId + " 被分配到登机口 " + availableGate.getId());
            } else {
                aircraft.waitForGate();
                System.out.println("飞机 " + aircraftId + " 需要等待可用登机口");
            }
        }
    }
  
    private Runway findAvailableRunway() {
        return runways.stream()
                .filter(runway -> !runway.isOccupied())
                .findFirst()
                .orElse(null);
    }
  
    private Gate findAvailableGate() {
        return gates.stream()
                .filter(gate -> !gate.isOccupied())
                .findFirst()
                .orElse(null);
    }
}

// 飞机类
public class Aircraft {
    private final String id;
    private final String type;
    private AirTrafficControlMediator mediator;
  
    public Aircraft(String id, String type) {
        this.id = id;
        this.type = type;
    }
  
    public void setMediator(AirTrafficControlMediator mediator) {
        this.mediator = mediator;
    }
  
    public void requestLanding() {
        if (mediator != null) {
            mediator.requestLanding(id);
        }
    }
  
    public void requestTakeoff() {
        if (mediator != null) {
            mediator.requestTakeoff(id);
        }
    }
  
    public void requestGate() {
        if (mediator != null) {
            mediator.requestGate(id);
        }
    }
  
    public void land(Runway runway) {
        System.out.println("飞机 " + id + " 降落在跑道 " + runway.getId());
    }
  
    public void takeoff(Runway runway) {
        System.out.println("飞机 " + id + " 从跑道 " + runway.getId() + " 起飞");
    }
  
    public void park(Gate gate) {
        System.out.println("飞机 " + id + " 停靠在登机口 " + gate.getId());
    }
  
    public void waitForRunway() {
        System.out.println("飞机 " + id + " 等待可用跑道");
    }
  
    public void waitForGate() {
        System.out.println("飞机 " + id + " 等待可用登机口");
    }
  
    // getter方法
    public String getId() { return id; }
    public String getType() { return type; }
}

3. 订单处理系统

// 订单处理中介者
public class OrderProcessingMediator {
    private final Map<String, Order> orders = new HashMap<>();
    private final List<OrderProcessor> processors = new ArrayList<>();
    private final List<OrderObserver> observers = new ArrayList<>();
  
    public void registerProcessor(OrderProcessor processor) {
        processors.add(processor);
        processor.setMediator(this);
    }
  
    public void registerObserver(OrderObserver observer) {
        observers.add(observer);
    }
  
    public void processOrder(Order order) {
        orders.put(order.getId(), order);
        notifyObservers("订单创建", order);
      
        for (OrderProcessor processor : processors) {
            if (processor.canProcess(order)) {
                processor.process(order);
                break;
            }
        }
    }
  
    public void updateOrderStatus(String orderId, OrderStatus status) {
        Order order = orders.get(orderId);
        if (order != null) {
            order.setStatus(status);
            notifyObservers("订单状态更新", order);
        }
    }
  
    private void notifyObservers(String event, Order order) {
        for (OrderObserver observer : observers) {
            observer.onOrderEvent(event, order);
        }
    }
}

// 订单类
public class Order {
    private final String id;
    private final String customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private final long createTime;
  
    public Order(String id, String customerId, List<OrderItem> items) {
        this.id = id;
        this.customerId = customerId;
        this.items = items;
        this.status = OrderStatus.PENDING;
        this.createTime = System.currentTimeMillis();
    }
  
    // getter和setter方法
    public String getId() { return id; }
    public String getCustomerId() { return customerId; }
    public List<OrderItem> getItems() { return items; }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    public long getCreateTime() { return createTime; }
}

// 订单处理器接口
public interface OrderProcessor {
    void setMediator(OrderProcessingMediator mediator);
    boolean canProcess(Order order);
    void process(Order order);
}

// 库存验证处理器
public class InventoryValidator implements OrderProcessor {
    private OrderProcessingMediator mediator;
  
    @Override
    public void setMediator(OrderProcessingMediator mediator) {
        this.mediator = mediator;
    }
  
    @Override
    public boolean canProcess(Order order) {
        return order.getStatus() == OrderStatus.PENDING;
    }
  
    @Override
    public void process(Order order) {
        System.out.println("验证订单库存: " + order.getId());
        // 验证库存逻辑
        if (validateInventory(order)) {
            mediator.updateOrderStatus(order.getId(), OrderStatus.CONFIRMED);
        } else {
            mediator.updateOrderStatus(order.getId(), OrderStatus.CANCELLED);
        }
    }
  
    private boolean validateInventory(Order order) {
        // 模拟库存验证
        return true;
    }
}

// 支付处理器
public class PaymentProcessor implements OrderProcessor {
    private OrderProcessingMediator mediator;
  
    @Override
    public void setMediator(OrderProcessingMediator mediator) {
        this.mediator = mediator;
    }
  
    @Override
    public boolean canProcess(Order order) {
        return order.getStatus() == OrderStatus.CONFIRMED;
    }
  
    @Override
    public void process(Order order) {
        System.out.println("处理订单支付: " + order.getId());
        // 支付处理逻辑
        if (processPayment(order)) {
            mediator.updateOrderStatus(order.getId(), OrderStatus.PAID);
        } else {
            mediator.updateOrderStatus(order.getId(), OrderStatus.PAYMENT_FAILED);
        }
    }
  
    private boolean processPayment(Order order) {
        // 模拟支付处理
        return true;
    }
}

面试高频点

面试知识点思维导图
中介者模式面试点
基本概念
实现方式
重难点
Spring应用
设计原则
实际应用
解耦对象交互
集中控制
简化通信
易于维护
Mediator抽象中介者
ConcreteMediator具体中介者
Colleague抽象同事类
ConcreteColleague具体同事类
复杂度管理
性能优化
扩展性
测试
ApplicationContext
ApplicationEventPublisher
ApplicationEventMulticaster
ApplicationListener
单一职责
开闭原则
依赖倒置
接口隔离
聊天室系统
飞机控制系统
订单处理系统
事件系统

1. 中介者模式的基本概念

问题：什么是中介者模式？

答案要点：

  • 用一个中介对象来封装一系列对象之间的交互
  • 使各对象不需要显式地相互引用，从而使其耦合松散
  • 属于行为型设计模式
  • 可以独立地改变它们之间的交互
问题：中介者模式有哪些角色？

答案要点：

  • Mediator（抽象中介者）：定义同事对象到中介者对象的接口
  • ConcreteMediator（具体中介者）：实现抽象中介者，协调各同事对象的交互关系
  • Colleague（抽象同事类）：定义各同事对象的公有接口
  • ConcreteColleague（具体同事类）：实现抽象同事类，通过中介者与其他同事对象通信

2. 实现方式相关

问题：如何实现中介者模式？

答案要点：

// 1. 定义抽象中介者
public abstract class Mediator {
    protected List<Colleague> colleagues = new ArrayList<>();
  
    public void register(Colleague colleague) {
        colleagues.add(colleague);
        colleague.setMediator(this);
    }
  
    public abstract void notify(Colleague sender, String message);
}

// 2. 定义抽象同事类
public abstract class Colleague {
    protected Mediator mediator;
  
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
  
    public abstract void send(String message);
    public abstract void receive(String message, Colleague sender);
}

// 3. 实现具体中介者
public class ConcreteMediator extends Mediator {
    @Override
    public void notify(Colleague sender, String message) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receive(message, sender);
            }
        }
    }
}

3. 重难点问题

问题：中介者模式与观察者模式的区别？

答案要点：

  • 目的：中介者模式是协调对象交互，观察者模式是通知状态变化
  • 关系：中介者模式是一对多，观察者模式是一对多
  • 耦合度：中介者模式耦合度更高，观察者模式耦合度更低
  • 使用场景：中介者模式用于复杂交互，观察者模式用于状态通知
问题：如何解决中介者的复杂度问题？

答案要点：

// 1. 分层中介者
public class LayeredMediator {
    private final Map<String, Mediator> mediators = new HashMap<>();
  
    public void addMediator(String layer, Mediator mediator) {
        mediators.put(layer, mediator);
    }
  
    public void notify(String layer, Colleague sender, String message) {
        Mediator mediator = mediators.get(layer);
        if (mediator != null) {
            mediator.notify(sender, message);
        }
    }
}

// 2. 使用策略模式
public class StrategyMediator {
    private final Map<String, MessageStrategy> strategies = new HashMap<>();
  
    public void addStrategy(String messageType, MessageStrategy strategy) {
        strategies.put(messageType, strategy);
    }
  
    public void notify(Colleague sender, String message) {
        String messageType = extractMessageType(message);
        MessageStrategy strategy = strategies.get(messageType);
        if (strategy != null) {
            strategy.handleMessage(sender, message);
        }
    }
}

4. Spring中的应用

问题：Spring中如何使用中介者模式？

答案要点：

// 1. 使用ApplicationEventPublisher
@Component
public class OrderService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
  
    public void createOrder(Order order) {
        // 创建订单逻辑
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
    }
}

// 2. 使用ApplicationListener
@Component
public class OrderEventListener implements ApplicationListener<OrderCreatedEvent> {
    @Override
    public void onApplicationEvent(OrderCreatedEvent event) {
        // 处理订单创建事件
        System.out.println("订单创建: " + event.getOrder().getId());
    }
}

5. 设计原则相关

问题：中介者模式体现了哪些设计原则？

答案要点：

  • 单一职责：中介者只负责协调对象交互
  • 开闭原则：可以添加新的同事对象而不修改现有代码
  • 依赖倒置：依赖抽象而不是具体实现
  • 接口隔离：客户端只依赖需要的接口

6. 实际应用场景

问题：中介者模式适用于哪些场景？

答案要点：

  • 聊天室系统：用户之间的消息传递
  • 飞机控制系统：飞机与塔台之间的通信
  • 订单处理系统：订单处理流程的协调
  • 事件系统：事件发布和订阅
  • GUI系统：界面组件之间的交互

使用总结

中介者模式的优势

  1. 解耦：减少对象之间的直接依赖关系
  2. 集中控制：将交互逻辑集中到中介者中
  3. 简化通信：简化对象之间的通信方式
  4. 易于维护：交互逻辑的修改只需要修改中介者

中介者模式的缺点

  1. 复杂度增加：中介者可能变得过于复杂
  2. 性能问题：中介者可能成为性能瓶颈
  3. 学习成本：需要理解中介者模式的概念
  4. 过度设计：简单场景可能不需要使用

使用建议

  1. 复杂交互：只用于复杂的对象交互场景
  2. 性能考虑：注意中介者的性能影响
  3. 扩展性：考虑中介者的扩展性设计
  4. 测试：做好中介者的单元测试

最佳实践

  1. 分层设计：使用分层中介者避免复杂度
  2. 策略模式：使用策略模式处理不同类型的消息
  3. 异步处理：使用异步处理提高性能
  4. 插件机制：使用插件机制提高扩展性
  5. 单元测试：为中介者编写完整的单元测试

与其他模式的对比

  1. 与观察者模式：中介者模式是协调交互，观察者模式是状态通知
  2. 与命令模式：中介者模式是协调对象，命令模式是封装请求
  3. 与策略模式：中介者模式是协调策略，策略模式是算法选择

中介者模式是一种有用的行为型设计模式，特别适用于需要协调复杂对象交互、集中控制交互逻辑、简化对象通信等场景。通过合理使用中介者模式，可以大大提高系统的可维护性和可扩展性。

java常用设计模式-中介者模式
08-28
Java 中介者模式详解 中介者模式（Mediator Pattern）是一种行为设计模式，它允许对象之间通过中介者对象进行通信，从而避免对象之间的直接耦合。中介者模式将对象之间的复杂关系转化为中介者和对象之间的简单关系...
Android编程设计模式之中介者模式详解
08-28
Android 编程设计模式之中介者模式详解 中介者模式（Mediator Pattern）是一种非常重要的设计模式，它主要用于解决多个对象之间的交互问题。在 Android 编程中，中介者模式广泛应用于解决复杂的对象交互问题。 ...
津津乐道设计模式 - 中介者模式详解（以房屋租赁平台的场景来演示中介者模式）
Micro麦可乐的博客
07-15 2752
本章节主要介绍了中介者模式、中介者模式适用场景、中介者模式的优缺点，以房屋租赁平台的场景来演示中介者模式，如果本文对你有用，欢迎关注收藏评论，后续将陆续推出更多优质的博文与大家一起分享交流～
C++ 设计模式——中介者模式
慢慢记录，慢慢更新。
08-30 3066
中介者模式（Mediator Pattern）是一种行为型设计模式，它允许对象间的通信被封装到一个中介者对象中。该模式的主要目的是减少多个对象和类之间的通信复杂性，通过创建一个集中的控制点来管理相互间的依赖关系。这种模式特别适用于大型系统中，可以帮助减少组件之间的直接交互，从而使其更易于维护和扩展。
设计模式-观察者模式详解
new_daimond的博客
09-19 598
本文系统介绍了观察者模式的设计原理与实现方法。首先定义了观察者模式的基本概念，它是一种一对多的依赖关系，允许主题对象状态变化时自动通知所有观察者。文章详细阐述了模式结构，包括主题、具体主题、观察者和具体观察者四个核心角色，并通过代码示例展示了完整的实现流程。重点分析了观察者模式中的三个关键问题：内存泄漏的预防方案、线程安全的实现方式以及观察者执行顺序的控制策略，分别给出了具体的解决方案和优化代码。全文通过流程图和代码示例，清晰呈现了观察者模式的核心思想和技术实现细节。
Java设计模式之中介者模式详解
季鸢的博客
05-29 2508
通过中介对象封装一组对象间的交互，将网状的对象关系转变为星型结构。如同机场控制塔协调所有飞机的起降，避免飞机之间直接通信导致的混乱。
详解设计模式：中介者模式
栗筝i的博客
12-06 3163
中介者模式（Mediator Pattern）也被称为调停者模式，是在 GoF 23 种设计模式中定义了的行为型模式。 中介者模式 是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。 本篇文章内容包括：关于中介模式、中介者模式 Demo
设计模式之中介者模式详解
glass__sky的博客
06-10 6619
一般来说，类之间的关系是比较复杂的，多个类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下左图中，有六个类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，类之间直接关联的设计是不好的。...
C++ 设计模式之 中介者模式
K1_uestc的博客
01-18 2139
第一行包括一个整数N,表示用户的数量（1
C# 设计模式之中介者模式
鲤籽鲲的博客
08-25 1271
C# 设计模式之中介者模式
设计模式-18中介者模式（中介者设计模式）详解
数字人生
08-16 176
用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。多个类相互耦合，形成了网状结构。将上述网状结构分离为星型结构。对象 Colleague 之间的通信封装到一个类中单独处理。1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。...
23种设计模式详解PDF
08-03
设计模式 的分类 总体来说设计模式分为三大类： 创建型模式（5）： 工厂方法模式 、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式（7）： 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、...
深入理解JavaScript系列（36）：设计模式之中介者模式详解
12-11
软件开发中，中介者是一个行为设计模式，通过提供一个统一的接口让系统的不同部分进行通信。一般，如果系统有很多子模块需要直接沟通，都要创建一个中央控制点让其各模块通过该中央控制点进行交互。中介者模式可以让...
C++编程原型设计模式
weixin_44311159的博客
11-22 780
摘要：原型设计模式通过复制现有对象创建新实例，避免高成本的对象初始化过程。其核心是定义原型接口（clone()方法），由具体类实现深拷贝或浅拷贝。该模式适用于对象创建开销大的场景（如游戏角色克隆、配置复用），能提高性能、增强灵活性并降低耦合。C++实现需注意深拷贝问题，建议结合注册表管理原型。优点是高效、动态扩展，缺点是深拷贝复杂性和适用性局限。改进方向包括引入原型管理器、优化克隆逻辑等。（149字）
Java设计模式之观察者模式
2509_93943236的博客
11-22 232
接着是ConcreteSubject（具体主题），它继承Subject类，内部维护实际状态数据，当状态改变时调用通知方法遍历观察者列表。最后是ConcreteObserver（具体观察者），实现Observer接口，在update()方法中定义自己的业务逻辑，比如刷新界面或保存日志。在编程世界里，这种模式让对象之间建立一种“一对多”的依赖关系：当一个核心对象（称为“主题”或“被观察者”）状态变化时，所有依赖它的对象（称为“观察者”）会自动收到通知并执行相应操作。实际开发中，观察者模式的应用场景非常广泛。
JavaScript设计模式详解
2509_93945761的博客
11-21 177
这玩意儿说白了就是个“包工头”，你告诉它你要啥（参数），它给你返回一个加工好的对象。比如，咱们要创建不同角色的用户，管理员、普通用户、VIP用户，总不能每次都一个然后手动塞属性吧？接下来咱们升级一下，聊聊装饰者模式。想象一下，你买了个新手机，想加个镜头、贴个膜，你不会把手机拆了重装吧？比如咱们要做个计算器，加减乘除，如果写一堆或者，以后每加一个运算就得改原来的代码，违反开闭原则。这个东西的好处是实现了模块间的完全解耦，发布者不知道谁订阅了它，订阅者也不知道消息来自哪里，各干各的，通过事件中心通信。
设计模式之原型模式在 C 语言中的应用（含 Linux 内核实例）
最新发布
鹰之翔
11-24 31
原型模式是一种创建型设计模式，通过复制已有对象（原型）来创建新对象，避免重复初始化。C语言实现时，使用结构体封装原型对象，通过函数指针定义克隆接口，支持浅克隆和深克隆。 示例1展示了用户对象的基础克隆，复制ID、姓名等属性。示例2演示了含动态内存属性的深克隆，确保复制指针指向的内容而非仅指针本身。原型模式适用于复杂对象初始化或批量创建相似对象场景，提高效率并保持一致性。 关键点： 原型模式解耦对象创建与实现 C语言通过结构体和函数指针实现 区分浅克隆（基础属性）和深克隆（动态内存） 适用于资源密集型对象的创
Java开发规范最佳实践
2509_93942857的博客
11-21 355
ERROR级别用来记录需要人工干预的错误，WARN级别关注异常情况，INFO级别记录关键业务流程，DEBUG级别留给开发调试用。最近在代码评审时看到个三百行的方法，里面塞了五层嵌套的ifelse，看着就跟俄罗斯套娃似的。把这些规范融入到日常开发中，时间长了就会发现，代码质量上去了，加班时间下来了，这才是双赢。遇到布尔类型的变量，记得用is、has、can这些前缀，比如、，读起来就跟说人话一样。见过为了用设计模式而用设计模式的，简单的业务逻辑硬是套上七八个设计模式，美其名曰“架构优雅”。
【设计模式】原型模式
phd的专栏
11-24 187
概念 创建型模式 类图 代码 #include <iostream> #include <unordered_map> #include <utility> using namespace std; class Shape { public: virtual ~Shape() = default; Shape(string proto) : name(std::move(proto)) {}; virtual Shape *Clone
Java设计模式：中介者模式详解及应用实例
中介者模式是Java设计模式中的一个重要行为类模式，它主要用于解耦系统中对象之间的复杂交互，使得类之间的依赖关系变得更加灵活且易于管理。在Java编程中，中介者模式通过一个中介者对象来协调一组同事类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值