当前位置：首页 > news >正文

Java中介者模式详解

news 来源：原创 2025/5/25 10:21:29

中介者模式详解

一、中介者模式概述

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

核心特点

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

二、中介者模式的结构

主要角色

Mediator：抽象中介者，定义通信接口
ConcreteMediator：具体中介者，协调各同事对象
Colleague：抽象同事类
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);
            }
        }
    }
}