设计模式-中介者模式

问题背景

一提到中介，我们首先就能想到租房中介，有租房中介在我们需要租房子的时候可以给我们节省很大精力。

那没有中介我们要怎么租房呢？

我们可以想象一下，因为我们对房子的需求不一样，我们身边的朋友不一定有适合的房子租给我们。我们就只能让朋友帮忙看看身边有没有拥有这样的房子。朋友问了以前自己亲戚朋友发现也没有这样的房子，就拜托亲戚朋友来帮忙去寻找，就这样一直依赖下去。

我们来将这个逻辑转换为UML类图来看看：

我们从这个类图来看，耦合性是多么的强，每一个亲戚朋友都要聚合到类中，每一个类都要写一个独立的方法来去寻找房子，这是多么大的工作量。

所以就出现了中介

我们来看一下有了中介后我们的租房UML类图

从这张图我们可以看出，每一个类都不需要去聚合很多类了，大大降低了耦合性，我们要租房只需要向中介说出需求，中介来告诉我们跟哪个房东租就可以了。房东有了房子告诉中介，中介让客户来直接联系房东即可。

中介者设计模式

基本介绍

1）中介者模式（Mediator Pattern），用一个中介对象来封装一系列对象交互。中介者使各个对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变他们之间地交互
2）中介者模式属于行为型模式，使代码易于维护

原理

1）Mediator抽象类就是中介者，定义了同事对象到中介者对象地接口
2）Colleague是抽象同事类
3）ConcreteMediator类是具体的中介者对象，实现抽象类Mediator，它需要知道所有的具体的同事类，存放在容器中。并且需要支持相应的操作来完成具体的任务
4）ConcreteColleague是具体的同事类，每个同事只知道自己的具体行为，不了解其他同事的行为，但是他们都依赖中介者对象，需要将自己交给中介者对象

问题解决-代码示例

房东接口

public interface HouseMaster {

    String getMobile();
}

中介抽象类

public abstract class Mediator {
    /**
     * 房东将房子注册到中介
     *
     * @param homeType
     * @param houseMaster
     */
    public abstract void add(String homeType, HouseMaster houseMaster);

    /**
     * 用户通过房子类型得到房东
     *
     * @param homeType
     * @return
     */
    public abstract HouseMaster get(String homeType);

}

房东一

public class HouseMaster01 implements HouseMaster{

    /**
     * 房子类型
     */
    private String homeType;

    /**
     * 联系方式
     */
    private String mobile = "12312312312";

    public HouseMaster01(String homeType, Mediator mediator) {
        this.homeType = homeType;
        mediator.add(homeType, this);
    }

    @Override
    public String getMobile() {
        return this.mobile;
    }
}

房东二

public class HouseMaster02 implements HouseMaster{

    /**
     * 房子类型
     */
    private String homeType;

    /**
     * 联系方式
     */
    private String mobile = "98798798798";

    public HouseMaster02(String homeType, Mediator mediator) {
        this.homeType = homeType;
        mediator.add(homeType, this);
    }

    @Override
    public String getMobile() {
        return this.mobile;
    }
}

房东三

public class HouseMaster03 implements HouseMaster{

    /**
     * 房子类型
     */
    private String homeType;

    /**
     * 联系方式
     */
    private String mobile = "56756756756";

    public HouseMaster03(String homeType, Mediator mediator) {
        this.homeType = homeType;
        mediator.add(homeType, this);
    }

    @Override
    public String getMobile() {
        return this.mobile;
    }
}

空实现

public class HouseMasterNoInfo implements HouseMaster{

    public HouseMasterNoInfo() {

    }

    @Override
    public String getMobile() {

        return null;
    }
}

中介类

public class ConcreteMediator extends Mediator{

    /**
     * 容器
     */
    private Map<String, HouseMaster> map = new HashMap<>();

    @Override
    public void add(String homeType, HouseMaster houseMaster) {
        map.put(homeType, houseMaster);
    }

    @Override
    public HouseMaster get(String homeType) {
        return map.getOrDefault(homeType, new HouseMasterNoInfo());
    }
}

租房测试代码

public class Client {
    public static void main(String[] args) {
        // 房屋中介
        ConcreteMediator concreteMediator = new ConcreteMediator();

        // 房东一
        new HouseMaster01("一室一厅", concreteMediator);
        // 房东二
        new HouseMaster02("两室一厅", concreteMediator);

        // 寻找房子-两室一厅
        HouseMaster houseMaster = concreteMediator.get("两室一厅");
        System.out.println(houseMaster.getMobile());

        // 寻找房子-三室一厅
        HouseMaster houseMaster1 = concreteMediator.get("三室一厅");
        System.out.println(houseMaster1.getMobile());

        // 房东三
        new HouseMaster03("三室一厅", concreteMediator);

        // 寻找房子-三室一厅
        HouseMaster houseMaster2 = concreteMediator.get("三室一厅");
        System.out.println(houseMaster2.getMobile());
    }
}

运行结果：

注意事项和细节

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