中介者模式又称调停者模式，属于行为型模式；中介者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

在中介者模式中，所有的成员对象都与一个处于中心地位的中介者对象发生紧密的联系，由这个中介者对象进行协调工作。所有被协调的对象称为同事对象。在所有同事对象内部发生的事件会影响到其他的同事对象，但是这种影响不是以直接管理的方式直接传到其他的对象上的，仅仅直接影响到中介者对象，而由中介者对象反过来协调其他的同事，形成整个系统的行为。

为什么需要中介者模式

在实际开发中，一个系统可能会调用周边的很多系统，那么在这个系统有大量的其他系统的实例对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。如下图所示，几乎每一个对象都需要与其他的对象发生相互作用，而这种相互作用表现为一个对象与另一个对象的直接耦合。这是一个过度耦合的系统。

通过引入中介者对象（Mediator)，可以将系统的网状结构变成以中介者为中心的星形结构，如下图所示。在这个星形结构中，同事对象不再通过直接的联系与另一个对象发生相互作用;相反地，它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入造成大量的修改工作。

比起传统的设计方法，面向对象的技术可以更好地协助开发者管理更为复杂的系统。一个好的面向对象的设计可以使对象之间增加协作性（Collaboration)，减少耦合度(Coupling)。一个深思熟虑的设计会把一个系统分解为一群相互协作的同事对象，给每一个同事对象以独特的责任，恰当的配置它们之间的协作关系，使它们可以在一起工作。

如同阿里开源的异构数据源离线同步工具--DataX,下图是他的设计图：

中介者模式的UML类图如下：

如上图所示，中介者模式涉及到四种角色：

1. 抽象中介者（Mediator）角色：定义出同事对象到中介者对象的接口，其中主要的方法是一个(或者多个）事件方法。在有些情况下，这个抽象对象可以省略。一般而言，这个角色由一个Java抽象类或者Java对象实现。
2. 具体调停者（ConcreteMediator）角色：从抽象中介者继承而来，实现了抽象类所声明的事件方法。具体中介者知晓所有的具体同事类，它从具体同事对象接收消息、向具体同事对象发出命令。―般而言，这个角色由具体Java类实现。
3. 抽象同事类（Colleague）角色：定义出中介者对象到同事对象的接口。同事对象只知道中介者而不知道其余的同事对象。一般而言，这个角色由一个Java抽象类或者Java对象实现。
4. 具体同事类（ConcreteColleague）角色：所有的具体同事类均从抽象同事类继承而来。每一个具体同事类都很清楚它自己在小范围内的行为，而不知道它在大范围内的目的；一般而言，这个角色由具体Java类实现。

智能家电的例子

在一个智能家电的系统中，包括闹钟、咖啡机、电视机、窗帘等家具组成，当主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作。比如：闹钟响起 --> 咖啡机打开做咖啡 --> 窗帘自动降下 --> 电视机开始播放；在这里就以这个为例子讲解。

例子的UML类图如下：

抽象中介者角色：

package com.charon.mediator;

/**
 * @className: Mediator
 * @description: 抽象中介者对象
 * @author: charon
 * @create: 2022-04-03 23:16
 */
public abstract class Mediator {

    /**
     * 将同事对象注册到中介者类中
     * @param colleagueName
     * @param colleage
     */
    abstract void register(String colleagueName, Colleague colleage);

    /**
     * 接收由具体的同事对象发出的消息
     * @param stateChange
     * @param colleagueName
     */
    abstract void getMessage(int stateChange,String colleagueName);

    /**
     * 发送消息
     */
    abstract void sendMessage();
}

具体中介者角色:

package com.charon.mediator;

import java.util.HashMap;
import java.util.Map;

/**
 * @className: ConcreteMediator
 * @description:
 * @author: charon
 * @create: 2022-04-03 23:26
 */
public class ConcreteMediator extends Mediator{

    /**
     * 用于存放所有的同事对象
     */
    private Map<String,Colleague> colleagueMap;

    private Map<String,String> interMap;

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

    @Override
    void register(String colleagueName, Colleague colleage) {
        colleagueMap.put(colleagueName,colleage);

        if(colleage instanceof Alarm){
            interMap.put("alarm",colleagueName);
        }else if(colleage instanceof CoffeeMachine){
            interMap.put("coffeeMachine",colleagueName);
        }else if (colleage instanceof TV){
            interMap.put("tv",colleagueName);
        }else if (colleage instanceof Curtains){
            interMap.put("curtains",colleagueName);
        }
    }

    @Override
    void getMessage(int state, String colleagueName) {
        if (colleagueMap.get(colleagueName) instanceof Alarm){
            if(state == 0){
                ((CoffeeMachine)colleagueMap.get(interMap.get("coffeeMachine"))).startCoffee();
                ((TV)colleagueMap.get(interMap.get("tv"))).startTv();
            }else if(state == 1){
                ((TV)colleagueMap.get(interMap.get("tv"))).stopTv();
            }
        }else if(colleagueMap.get(colleagueName) instanceof CoffeeMachine){
            ((Curtains)colleagueMap.get(interMap.get("curtains"))).upCurtains();
        }
    }

    @Override
    void sendMessage() {

    }
}

抽象同事角色：

package com.charon.mediator;

/**
 * @className: Colleague
 * @description:
 * @author: charon
 * @create: 2022-04-03 23:18
 */
public abstract class Colleague {

    private Mediator mediator;

    private String name;

    public Colleague(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    /**
     * Gets the value of mediator
     *
     * @return the value of mediator
     */
    public Mediator getMediator() {
        return mediator;
    }

    /**
     * Gets the value of name
     *
     * @return the value of name
     */
    public String getName() {
        return name;
    }

    abstract void sendMessage(int stateChange);
}

具体同事角色：

package com.charon.mediator;

/**
 * @className: Curtains
 * @description: 窗帘
 * @author: charon
 * @create: 2022-04-03 23:34
 */
public class Curtains extends Colleague{
    @Override
    void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }

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

    public void upCurtains(){
        System.out.println("窗帘在上升。。。。");
    }

    public void downCurtains(){
        System.out.println("窗帘在下降。。。。");
    }
}

package com.charon.mediator;

/**
 * @className: TV
 * @description:
 * @author: charon
 * @create: 2022-04-03 23:33
 */
public class TV extends Colleague{

    public TV(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name, this);
    }

    @Override
    void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }

    public void startTv(){
        System.out.println("电视机开机。。。");
    }

    public void stopTv(){
        System.out.println("电视机关机。。。");
    }
}


package com.charon.mediator;

/**
 * @className: CoffeeMachine
 * @description:
 * @author: charon
 * @create: 2022-04-03 23:32
 */
public class CoffeeMachine extends Colleague{
    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    @Override
    void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }

    public void startCoffee(){
        System.out.println("咖啡机启动。。。。");
    }

    public void stopCoffee(){
        System.out.println("咖啡机关闭。。。。");
        sendMessage(0);
    }
}

package com.charon.mediator;

/**
 * @className: Alarm
 * @description:
 * @author: charon
 * @create: 2022-04-03 23:30
 */
public class Alarm extends Colleague{
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    @Override
    void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }

    void sendAlarm(int statChange){
        sendMessage(0);
    }
}

客户端测试：

package com.charon.mediator;

/**
 * @className: Client
 * @description: http://c.biancheng.net/view/1393.html
 * @author: charon
 * @create: 2022-03-31 23:14
 */
public class Client {

    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Alarm alarm = new Alarm(mediator, "alarm");
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
        Curtains curtain = new Curtains(mediator, "curtain");
        TV tv = new TV(mediator, "tv");

        // 闹钟发出声响
        alarm.sendAlarm(0);
        coffeeMachine.stopCoffee();
        alarm.sendAlarm(1);
    }
}

打印：
    咖啡机启动。。。。
    电视机开机。。。
    咖啡机关闭。。。。
    窗帘在上升。。。。
    咖啡机启动。。。。
    电视机开机。。。

中介者模式的主要优点如下：

1. 类之间各司其职，符合迪米特法则
2. 降低了对象之间的耦合性，使得对象易于独立地被复用
3. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展

其主要缺点是：

1. 中介者模式降低了同事对象的复杂性，代价是增加了中介者类的复杂性
2. 中介者类经常充满了各个具体同事类的关系协调代码，这种代码常常是不能复用的，因此，具体同事类的复用是以中介者类的不可复用为代价的
3. 中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护

中介者模式的应用场景

• 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

中介者模式与门面模式的区别

门面模式和中介者模式很相似，两者均是用来给出一个底耦合度的系统。门面模式为一个子系统提供一个简单的接口，其中消息的传送时单方向的，因为门面模式的客户端只通过门面类向子系统发出消息，而不是相反的情况。

中介者模式则是中介类与同事对象的相互作用是多方向的。

中介者模式与观察者模式的区别

中介者模式与观察者模式是功能相类似的设计模式，它们之间是相互竞争的关系。换言之，使用了其中一者往往意味着放弃另一者。观察者模式通过引入观察者对象和主题对象来达到将通信分散化的目的；而中介者模式则封装了对象之间的通信，从而将通信集中到一个个中介对象中。

观察者模式需要观察者对象和主题对象的相互协作才能达到目的，而且一个观察主题对象通常有几个观察者对象，而一个观察者对象也可以同时观察几个主题对象。

由于观察者模式将性能分散到几个对象中，因此更容易达到复用的目的。但是由于每一次通信都涉及几个对象，因此，使用观察者模式的设计可能不容易读懂。使用了中介者模式使得系统的通信都要经过这个中介者对象，在所涉及的同事对象数目不多的情况下，使用中介者模式的设计是比较容易懂的设计。

在观察者模式中，观察者与被观察者是不同的角色；而在中介者模式中，所有的同事对象都扮演同样的角色。