简介

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

中介者模式属于行为型模式，使代码易于维护。

比如 MVC 模式，C（Controller 控制器）是 M（Model 模型）和 V（View 视图）的中介者，在前后端交互时起到了中间人的作用。

代码示例

例如：智能家庭项目

• 智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等。
• 主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起 -> 电视打开 -> 窗帘打开 -> 咖啡机打开。

/**
 * 抽象中介者
 */
public abstract class SmartHomeMediator {

    /**
     * 注册
     * @param deviceName    设备名称
     * @param device        具体的设备
     */
    abstract void register(String deviceName, Device device);

    /**
     * 核心方法，接收消息，协调具体的同事来完成任务
     *
     * @param command    消息
     * @param sender     具体的设备
     */
    abstract void executeAction(int command, Device sender);
}

/**
 * 同事抽象类
 */
public abstract class Device {

    private final SmartHomeMediator mediator;

    public Device(SmartHomeMediator mediator) {
        this.mediator = mediator;
    }


    public void performAction(int command) {
        mediator.executeAction(command, this);
    }
}

/**
 * 具体同事类 - 电视
 */
public class TV extends Device {
    public TV(String name, SmartHomeMediator mediator) {
        super(mediator);
        mediator.register(name, this);
    }
    public void open() {
        System.out.println("打开电视");
    }

    public void close() {
        System.out.println("关闭电视");
    }
}

/**
 * 具体同事类 - 窗帘
 */
public class Curtains extends Device {

    public Curtains(String name, SmartHomeMediator mediator) {
        super(mediator);
        mediator.register(name, this);
    }

    public void open() {
        System.out.println("拉开窗帘");
    }

    public void close() {
        System.out.println("拉上窗帘");
    }
}

public class CoffeeMachine extends Device {
    public CoffeeMachine(String name, SmartHomeMediator mediator) {
        super(mediator);
        mediator.register(name, this);
    }
    public void open() {
        System.out.println("打开咖啡机");
    }

    public void close() {
        System.out.println("关闭咖啡机");
    }
}

// 具体同事类 - 闹钟
public class Alarm extends Device {
    public Alarm(String name, SmartHomeMediator mediator) {
        super(mediator);
        mediator.register(name, this);
    }

    public void startMorning() {
        System.out.println("起床闹钟响起");
    }

    public void stop() {
        System.out.println("关闭闹钟");
    }

}

/**
 *  具体的中介者类,如果闹钟发送消息1为开始打开窗帘、打开咖啡机、打开电视，如果电视发送消息1为打开电视、关闭窗帘。
 */
public class ConcreteMediator extends SmartHomeMediator {
    private final Map<String, Device> devices;

    public ConcreteMediator() {
        this.devices = new HashMap<>();
    }


    /**
     * 注册
     *
     * @param device 具体的同事
     */
    @Override
    void register(String deviceName, Device device) {
        devices.put(deviceName, device);
    }

    /**
     * 核心方法，接收消息，协调具体的同事来完成任务
     *
     * @param command    消息
     * @param sender     具体的同事
     */
    @Override
    void executeAction(int command, Device sender) {
        if (sender instanceof Alarm) {
            if (command == 1) {
                // 打开窗帘、电视、咖啡机
                // 关闭闹钟
                Alarm alarm = (Alarm) devices.get("闹钟");
                alarm.stop();
                Curtains curtains = (Curtains) devices.get("窗帘");
                curtains.open();
                TV tv = (TV) devices.get("电视");
                tv.open();
                CoffeeMachine coffeeMachine = (CoffeeMachine) devices.get("咖啡机");
                coffeeMachine.open();
            }
            // else-if
        } else if (sender instanceof TV) {
            //打开电视、关闭窗帘。
            TV tv = (TV) devices.get("电视");
            tv.open();
            Curtains curtains = (Curtains) devices.get("窗帘");
            curtains.close();
        }
    }
}

public class Client {
    public static void main(String[] args) {
        SmartHomeMediator mediator = new ConcreteMediator();
        Alarm device = new Alarm("闹钟", mediator);
        Curtains curtains = new Curtains("窗帘",mediator);
        TV tv = new TV("电视",mediator);
        CoffeeMachine coffeeMachine = new CoffeeMachine("咖啡机",mediator);
        // 闹钟响起,开始打开窗帘、打开咖啡机、打开电视
        device.startMorning();
        device.performAction(1);
    }
}

说明

1. 多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦。
2. 减少类间依赖，降低了耦合，符合迪米特原则。
3. 中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响。
4. 如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意。