一、白话

  我们经常会使用微博，抖音啥的，我希望能够分享一个视频给喜欢美女的人（我并不知道这些人是谁，如何联系），于是我贴了个标签“美女”，这样，喜欢美女的人就会被抖音推送该视频，我通过抖音这个中介，完成了和其他人的消息互动。再比如告白墙，我喜欢某个女生小芳，但是我并没有这个女生的联系方式，于是我直接写在告白墙上，这样小芳看告白墙的时候，就接受到了这条消息。 中介者模式就是，所有人都只能通过中介进行联系。

二、定义

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

• 抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。
• 中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。
• 同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

三、示例

// 抽象中介者-定义一系列中介接口
public abstract class Mediator {
    public abstract void receive(String msg);
    public abstract void send(String msg);
    public abstract void sendToXiaoFang(String msg);
}

// 具体抽象者-告白墙
public class ConfessionWall extends Mediator {
    private User xiaoFang;
    private User xiaoMing;
    private User xiaoWang;

    // 这里讲收到的消息发送给了所有人，也可以根据实际情况，发送给单独的一个两个人，不一定都要发给所有人
    @Override
    public void receive(String msg) {
        send(msg);
    }

    public void sendToXiaoFang(String msg) {
        xiaoFang.receiveMsg(msg);
    }

    @Override
    public void send(String msg) {
        xiaoFang.receiveMsg(msg);
        xiaoMing.receiveMsg(msg);
        xiaoWang.receiveMsg(msg);
    }

    public User getXiaoFang() {
        return xiaoFang;
    }

    public void setXiaoFang(User xiaoFang) {
        this.xiaoFang = xiaoFang;
    }

    public User getXiaoMing() {
        return xiaoMing;
    }

    public void setXiaoMing(User xiaoMing) {
        this.xiaoMing = xiaoMing;
    }

    public User getXiaoWang() {
        return xiaoWang;
    }

    public void setXiaoWang(User xiaoWang) {
        this.xiaoWang = xiaoWang;
    }
}

// 具体同事类-用户
public class User {
    // 持有中介者
    private Mediator mediator;
    // 名字
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void sendMsg(String msg){
        System.out.println(name + "通过中介，发布了消息:" + msg);
        mediator.receive(msg);
    }


    public void sendToXiaoFang(String msg) {
        System.out.println(name + "通过中介，给小芳发送了消息:" + msg);
        mediator.sendToXiaoFang(msg);
    }


    public void receiveMsg(String msg) {
        System.out.println(name + "收到了消息:" + msg);
    }



    public Mediator getMediator() {
        return mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class MediatorApplication {
    // 客户端调用
    public static void main(String[] args) {
        // 设置三个用户 小明、小芳、小王
        User xiaoMing = new User("小明");
        User xiaoFang = new User("小芳");
        User xiaoWang = new User("小王");

        // 设置中介者，持有所有用户信息  同时所有人都只有中介者消息
        ConfessionWall confessionWall = new ConfessionWall();
        confessionWall.setXiaoFang(xiaoFang);
        confessionWall.setXiaoMing(xiaoMing);
        confessionWall.setXiaoWang(xiaoWang);

        xiaoMing.setMediator(confessionWall);
        xiaoFang.setMediator(confessionWall);
        xiaoWang.setMediator(confessionWall);

        // 通过中介者发送消息
        xiaoMing.sendToXiaoFang("我喜欢你");
        xiaoWang.sendMsg("我爸是李刚");
    }
}

输出示例：

小明通过中介，给小芳发送了消息:我喜欢你
小芳收到了消息:我喜欢你
小王通过中介，发布了消息:我爸是李刚
小芳收到了消息:我爸是李刚
小明收到了消息:我爸是李刚
小王收到了消息:我爸是李刚

四、总结

  特点：1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。4、中介者会庞大，变得复杂难以维护。