Java编程之中介者模式（Mediator Pattern）

一、什么是中介者模式

中介者模式是一种行为型设计模式，用于减少多个对象和类之间的通信复杂性。该模式通过一个中介者对象来封装一系列对象之间的交互，使原本对象之间的网状关系，变成了星型关系。

换句话说，各个组件不直接通信，而是通过“中介”统一协调，这就像一个“调度中心”在传话。

二、举例说明

客人住进一家酒店

• 客人想要打扫卫生、修空调、订餐等，都可以联系前台。

• 前台再分别通知：保洁、维修、厨房……

各个服务部门彼此之间不通信，都由“前台”协调。

这正是中介者模式的典型结构：

• 前台（Mediator）是中介者

• 各部门（Colleague）是参与者

• 客人只需要找前台，系统变得更简洁、灵活、低耦合

前台中介者，减少了复杂的沟通成本。

三、中介者模式的结构图（UML）

@startuml
interface Mediator {
    +notify(String request, Department sender)
}

abstract class Department {
    protected Mediator mediator
    +sendRequest(String request)
    +receiveRequest(String request)
}

class HotelFrontDesk implements Mediator {
    - cleaning: CleaningService
    - kitchen: KitchenService
    - maintenance: MaintenanceService
    +notify(String request, Department sender)
}

class CleaningService extends Department
class KitchenService extends Department
class MaintenanceService extends Department

Mediator <|.. HotelFrontDesk
Department <|-- CleaningService
Department <|-- KitchenService
Department <|-- MaintenanceService
HotelFrontDesk o-- CleaningService
HotelFrontDesk o-- KitchenService
HotelFrontDesk o-- MaintenanceService
@enduml

四、Java 示例代码

抽象中介者接口

public interface Mediator {
    void notify(String request, Department sender);
}

抽象部门类

public abstract class Department {
    protected Mediator mediator;

    public Department(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void sendRequest(String request);
    public abstract void receiveRequest(String request);
}

具体部门实现类（保洁、厨房、维修）

public class CleaningService extends Department {
    public CleaningService(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendRequest(String request) {
        System.out.println("保洁发出请求：" + request);
        mediator.notify(request, this);
    }

    @Override
    public void receiveRequest(String request) {
        System.out.println("保洁收到请求：" + request);
    }
}

public class KitchenService extends Department {
    public KitchenService(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendRequest(String request) {
        System.out.println("厨房发出请求：" + request);
        mediator.notify(request, this);
    }

    @Override
    public void receiveRequest(String request) {
        System.out.println("厨房收到请求：" + request);
    }
}

public class MaintenanceService extends Department {
    public MaintenanceService(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendRequest(String request) {
        System.out.println("维修发出请求：" + request);
        mediator.notify(request, this);
    }

    @Override
    public void receiveRequest(String request) {
        System.out.println("维修收到请求：" + request);
    }
}

前台中介者实现

public class HotelFrontDesk implements Mediator {
    private CleaningService cleaning;
    private KitchenService kitchen;
    private MaintenanceService maintenance;

    public void setCleaningService(CleaningService cleaning) {
        this.cleaning = cleaning;
    }

    public void setKitchenService(KitchenService kitchen) {
        this.kitchen = kitchen;
    }

    public void setMaintenanceService(MaintenanceService maintenance) {
        this.maintenance = maintenance;
    }

    @Override
    public void notify(String request, Department sender) {
        if (sender instanceof CleaningService) {
            // 保洁发起，转发给厨房和维修
            kitchen.receiveRequest("前台转发来自保洁的请求: " + request);
            maintenance.receiveRequest("前台转发来自保洁的请求: " + request);
        } else if (sender instanceof KitchenService) {
            cleaning.receiveRequest("前台转发来自厨房的请求: " + request);
            maintenance.receiveRequest("前台转发来自厨房的请求: " + request);
        } else if (sender instanceof MaintenanceService) {
            cleaning.receiveRequest("前台转发来自维修的请求: " + request);
            kitchen.receiveRequest("前台转发来自维修的请求: " + request);
        }
    }
}

客户端测试

public class Client {
    public static void main(String[] args) {
        HotelFrontDesk frontDesk = new HotelFrontDesk();

        CleaningService cleaning = new CleaningService(frontDesk);
        KitchenService kitchen = new KitchenService(frontDesk);
        MaintenanceService maintenance = new MaintenanceService(frontDesk);

        frontDesk.setCleaningService(cleaning);
        frontDesk.setKitchenService(kitchen);
        frontDesk.setMaintenanceService(maintenance);

        // 保洁请求支援
        cleaning.sendRequest("请协助清理溢出的食物残渣");
        
        // 厨房请求支援
        kitchen.sendRequest("需要清洁地面");
    }
}

五、优点与适用场景

优点

• 降低对象之间的耦合
• 集中控制，便于维护和扩展
• 便于复用和单元测试

适用场景

• 多个对象存在复杂的交互关系（如 GUI 控件、聊天室）
• 系统中对象之间强耦合，难以复用
• 想引入一个“协调者”统一调度行为

六、现实中的应用案例

• GUI框架中控件通信：按钮点击 → 通知中介 → 中介控制其他控件状态
• 飞机塔台通信系统：飞机之间不直接通信，而都与塔台协调
• 聊天室系统：用户不直接通信，而通过服务器转发

七、小结

项目	内容
🧠 核心思想	引入一个中介者，统一管理组件之间的通信
🎯 优点	降低耦合、集中控制
⚠️ 注意	中介者本身可能变得复杂

中介者模式的目标是“松耦合”，它是让对象之间“不认识彼此”，但却配合得天衣无缝。

八、参考

《23种设计模式概览》