中介者模式：定义一个中介者对象，其中包含了一系列彼此之间有相互关联的对象，通过中介者来管理这些对象之间的关系，而不是对象直接之间发生联系。

使用一个例子来说明一下：假设有两个村子A和B，在A村中的一些人和B村中的一些人是亲戚朋友关系，人们不忙了就会邀请在另外一个村子的亲戚朋友前来做客，在没有手机电话的年代，就需要靠人来送信。最开始的时候，就是很简单大家各自送各自的信，知道自己的亲戚朋友在哪儿住，直接就找上门去了。后来有个人看到了其中的商机，就站出来跟大家说，我来帮你们送信吧，每封信收你们一块钱，只需要把你们亲戚朋友的地址和名字写在信封上，我就可以按照信封上的信息把信送到指定的人手中 。慢慢的大家觉得这个事儿挺好，省事儿，就都来找这个人送信，这就是后来的邮递员的角色。

在这个实例中，刚开始人们各自送各自的信，大家之间的关系就像是一个网状的关系，到后来这个邮递员出现之后就变成了一个星型关系，因为大家彼此之间不再需要联系，只需要跟这个邮递员联系就好了。中介者模式就是这个星型关系的模式。

下面用中介者模式来实现一下：

关联对象的抽象

public interface Colleague {

    public void setPostman(Postman postman);

    public void send(String message, Integer toNum);

    public void recieve(String message,Integer fromNum);
}

中介者：

public class Postman {
    // 用一个集合来保存需要联系的对象
    // 这里我们选择用一个map来保存，key就是对象的编号，为了方便定位对象
    Map<Integer, Colleague> colleagueMap = new HashMap<>();

    // 添加具体对象
    public void add(Integer number, Colleague colleague) {
        colleague.setPostman(this);
        colleagueMap.put(number, colleague);
    }

    // 处理消息
    public void deal(String message,Integer from, Integer toNum){
        // 找到接受消息的对象，调用它的接受方法
        Colleague colleague = colleagueMap.get(toNum);
        colleague.recieve(message, from);
    }
}

具体的关联对象：

public class Colleague1 implements Colleague {
    public Integer number = 1;  // 为了测试方便
    private Postman postman;

    @Override
    public void setPostman(Postman postman) {
        this.postman = postman;
    }

    @Override
    public void send(String message, Integer toNum) {
        System.out.println("1号: 给" + toNum + "号发送了一条消息：" + message);
        // 中介者处理
        postman.deal(message, 1, toNum);
    }

    @Override
    public void recieve(String message, Integer fromNum) {
        System.out.println("1号: 收到" + fromNum + "号收到一条消息：" + message);
    }
}

public class Colleague2 implements Colleague {
    public Integer number = 2;
    private Postman postman;

    @Override
    public void setPostman(Postman postman) {
        this.postman = postman;
    }

    @Override
    public void send(String message, Integer toNum) {
        System.out.println("2号: 给" + toNum + "号发送了一条消息：" + message);
        // 中介者处理
        postman.deal(message, 2, toNum);
    }

    @Override
    public void recieve(String message, Integer fromNum) {
        System.out.println("2号: 收到" + fromNum + "号收到一条消息：" + message);
    }
}

public class Colleague3 implements Colleague {
    public Integer number = 3;
    private Postman postman;

    @Override
    public void setPostman(Postman postman) {
        this.postman = postman;
    }

    @Override
    public void send(String message, Integer toNum) {
        System.out.println("3号: 给" + toNum + "号发送了一条消息：" + message);
        // 中介者处理
        postman.deal(message, 3, toNum);
    }

    @Override
    public void recieve(String message, Integer fromNum) {
        System.out.println("3号: 收到" + fromNum + "号收到一条消息：" + message);
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        // 准备好关联的对象
        Colleague1 colleague1 = new Colleague1();
        Colleague2 colleague2 = new Colleague2();
        Colleague3 colleague3 = new Colleague3();
        // 准备好中介者对象，以及构建中介者和其他对象之间的关系
        Postman postman = new Postman();
        postman.add(colleague1.number, colleague1);
        postman.add(colleague2.number, colleague2);
        postman.add(colleague3.number, colleague3);

        // 测试发送消息
        colleague1.send("明天来我家吃饭吧，红烧肉", 2);
        colleague1.send("明天来我家吃饭吧，红烧肉", 3);
        colleague2.send("我准备和3号去钓鱼，改天吧",1);
        colleague2.send("明天我们一起去钓鱼吧",3);
        colleague3.send("可是我想去1号家吃红烧肉",2);
    }
}

小结一下：中介者模式很明显的好处就是简化了对象直接的关系，降低了耦合，使得其他对象只和中介者发生关系。但是问题也是这点，当发生联系的对象比较多时，中介者的负担就比较重，而且需要提前把其他对象的信息维护到中介者对象中，当需要扩展时，也需要修改中介者对象的代码。