1 租房需求

我们以日常生活中的租房子为例，通常租房子是直接联系房东看房，如果满意就签合同，如果不满意就需要我们自己再去联系其他房东。比如，我们现在想租一个双人间，联系了房东1，发现房东1出租的是单间，而恰巧房东1认识房东2正在出租双人间，于是我们又联系了房东2，但是房东2的房间已经租出去了，房东2又有一个朋友房东3也在出租双人间，于是我们又联系了房东3，直到租到合适的房子为止。
从上面租房的整个过程可以看到，租客需要和所有房东耦合，并且房东和房东之间也存在耦合，这种模式对于租客和房东都是不友好的。于是乎，社会上出现了中介者这样一种职业，房东把房子交给中介者来管理，租客要租房子也直接找中介者，这样租客和房东以及房东和房东之间的耦合都不存在了。

2 中介者模式介绍

中介者模式（Mediator Pattern）是用一个中介对象来封装一系列的对象交互。中介者使得各个对象之间不需要显式的相互引用，从而使得其耦合松散，而且可以独立地改变它们之间的交互。中介者属于行为性模式，是代码易于维护。
角色分析：
1）Mediator：中介者，定义了同事对象到中介者对象的接口
2）Colleague：抽象的同事类，即房东的抽象
3）ConcreteMeaditor：具体的中介者实现类，它需要知道具体的同事类，可以用一个集合来管理
4）ConcreteColleague：具体的同事实现类，即具体的房东，每个同事类知道自己的行为，而不了解其他同事类的行为，他们都依赖中介者对象
5）Client：客户端类，即租客，客户端只依赖于中介者，不感知房东

中介者模式类图

3 代码实现

首先有抽象的同事类，即抽象的房东：

public abstract class Colleague {
    // 房东决定房子的租金，水电等其他信息
    public abstract void handle();
}

房东有三个实现类：单间、双人间和三人间

public class SingleRoom extends Colleague {
    public SingleRoom(Mediator mediator, String name) {
        mediator.register(name, this);
    }

    @Override
    public void handle() {
        System.out.println("出租单间：月租金1500，不允许带其他人入住");
    }
}

public class DoubleRoom extends Colleague {
    public DoubleRoom(Mediator mediator, String name) {
        mediator.register(name, this);
    }

    @Override
    public void handle() {
        System.out.println("出租双人间：月租金2500，若是情侣入住，房租减半水电全免");
    }
}

public class TripleRoom extends Colleague {
    public TripleRoom(Mediator mediator, String name) {
        mediator.register(name, this);
    }

    @Override
    public void handle() {
        System.out.println("三人间出租：月租金4200，水电自己交");
    }
}

然后是抽象的中介者：

public abstract class Mediator {
    // 将一个房东对象加入到集合中
    public abstract void register(String name, Colleague colleague);
    // 租客调用该方法租房
    public abstract void common(String name);
}

中介者的具体实现：

public class ConcreteMediator extends Mediator {
    // 存放所有房东对象
    private HashMap<String, Colleague> colleagueMap;

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

    @Override
    public void register(String name, Colleague colleague) {
        colleagueMap.put(name, colleague);
    }

    @Override
    public void common(String name) {
        if (colleagueMap.containsKey(name)) {
            colleagueMap.get(name).handle();
            System.out.println("如果满意就签合同吧");
        } else {
            System.out.println("很抱歉，没有" + name + "的房子出租");
        }
    }
}

客户端实现，即租客来租房：

public class Client {
    public static void main(String[] args) {
        // 创建中介者
        Mediator mediator = new ConcreteMediator();

        // 房东把房子交给中介者
        Colleague colleague1 = new SingleRoom(mediator, "单间");
        Colleague colleague2 = new DoubleRoom(mediator, "双人间");
        Colleague colleague3 = new TripleRoom(mediator, "三人间");

        // 租客来租房：
        // 第一个租客想要一个单间
        System.out.println("======================");
        mediator.common("单间");
        // 第二个租客想要一个双人间
        System.out.println("======================");
        mediator.common("双人间");
        // 第三个租客想要四人间
        System.out.println("======================");
        mediator.common("四人间");
    }
}

输出结果：

======================
出租单间：月租金1500，不允许带其他人入住
如果满意就签合同吧
======================
出租双人间：月租金2500，若是情侣入住，房租减半水电全免
如果满意就签合同吧
======================
很抱歉，没有四人间的房子出租

租房需求的类图

4 中介者模式的注意事项

1）多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离成星型结构，可以减少耦合。
2）中介者模式可以减少类之间的依赖，符合迪米特法则。
3）中介者承担了较多的责任，一旦中介者出现了问题，整个系统会受到影响。
4）如果设计不当，会使得中介者对象变得很复杂，在实际应用中要特别注意。