中介者模式-协调多个对象之间的交互

 在深圳租房市场，有着许多的“二房东”，房主委托他们将房子租出去，而租客想要租房的话，也是和“二房东”沟通，租房期间有任何问题，找二房东解决。对于房主来说，委托给“二房东”可太省事了，只要签个委托协议，然后坐等收钱就可以了，可以不要跟租客打交道。 而对于租客来说，租房期间的任何问题，找“二房东”解决也比较方便。 当然付出的代价就是“中间商赚差价”了。这就是中介者模式。

1 中介者模式概述

如果一个系统中对象之间的联系呈现为网状结构，对象之间存在大量的多对多联系，将导致系统非常复杂。它们之间通过彼此相互作用实现系统的行为。这将导致系统过度耦合。

图 对象之间存在复杂关系的网状结构

通过引人中介者对象，可以将系统的网状结构变成以中介者为中心的星形结构。在这个星形结构中，同事对象不再之间与另一个对象联系，它通过中介者对象与另一个对象发生相互作用。

图 引入中介者对象的星形结构

中介者模式可以使对象之间的关系数量急剧减少。保证了对象结构上的稳定，系统的结构不会因为新对象的引入带来大量的修改工作。

1.1 模式定义

如果在一个系统中对象之间存在多对多的相互关系，可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，由该中介者进行统一协调。

这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。中介者模式是迪米特法则的一个典型应用。

图 中介者模式结构图

Mediator：抽象中介者，定义一个接口，用于与各同事对象之间进行通信。

ConcreteMediator: 具体中介者，通过协调各个同事对象来实现协作行为，维持了对各个同事对象的引用。

Colleague：抽象同事类，定义各个同事类公有的方法，并声明了一些抽象方法供子类实现，同时维持了一个对抽象中介者类的引用。

ConcreteColleague：具体同事类，当每个同事对象在需要和其他同事对象通信时，先于中介者通信，通过中介者来间接完成与其他同事类的通信。

public abstract class Colleague {

    protected final String name;

    protected Mediator mediator;

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

    /**
     * 租房
     */
    public abstract void renting(String position, double price, double area);

}


public class Landlord extends Colleague{

    public Landlord(String name, Mediator mediator) {
        super(name, mediator);
    }

    // 发布房源信息
    @Override
    public void renting(String position, double price, double area) {
        mediator.publish(this,position,price,area);
    }

    @Override
    public String toString() {
        return "房东:" + name;
    }
}

public class Tenant extends Colleague{

    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }

    // 求租
    @Override
    public void renting(String position, double price, double area) {
        mediator.renting(this,position,price,area);
    }

    @Override
    public String toString() {
        return "租客:" + name;
    }
}

public interface Mediator {

    /**
     * 租房
     *
     * @param position
     *          位置
     * @param price
     *          价格
     * @param area
     *          面积
     */
    void renting(Tenant tenant,String position, double price, double area);

    /**
     * 发布房源信息
     *
     */
    void publish(Landlord landlord,String position, double price, double area);

}

public class ConcreteMediator implements Mediator{

    /**
     * 房东集合
     */
    private final Set<Landlord> landlords = new HashSet<>();

    /**
     * 租户集合
     */
    private final Set<Tenant> tenants = new HashSet<>();

    /**
     * 房源信息集合
     */
    private final List<RoomInfo> roomInfos = new ArrayList<>();

    @Override
    public void renting(Tenant tenant, String position, double price, double area) {
        System.out.print("【" + position + ",价格：" + price + "以下,面积" + area + "】");
        tenants.add(tenant);
        for (RoomInfo item : roomInfos) {
            if (item.getTenant() == null) {
                if (item.getPosition().equals(position) && item.getPrice() <= price && item.getArea() >= area) {
                    item.setTenant(tenant);
                    System.out.println("租房成功:" + item);
                    return;
                }
            }
        }
        System.out.println("没有找到合适的房源");

//        运行结果:
//        【罗湖区,价格：1800.0以下,面积25.0】没有找到合适的房源
//        【福田区,价格：3000.0以下,面积25.0】租房成功:RoomInfo(price=28.0, area=2800.0, position=福田区, tenant=租客:李四, landlord=房东:老张)
    }

    @Override
    public void publish(Landlord landlord, String position, double price, double area) {
        landlords.add(landlord);
        RoomInfo roomInfo = new RoomInfo();
        roomInfo.setLandlord(landlord);
        roomInfo.setPosition(position);
        roomInfo.setPrice(price);
        roomInfo.setArea(area);
        roomInfos.add(roomInfo);
    }

}

@Data
public class RoomInfo {

    private double price;

    private double area;

    private String position;

    private Tenant tenant;

    private Landlord landlord;

}

public class Client {

    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();

        Landlord landlord1 = new Landlord("老张",mediator);
        landlord1.renting("福田区",28,2800);
        landlord1.renting("福田区",20,2200);
        landlord1.renting("福田区", 7, 1500);

        Landlord landlord2 = new Landlord("老黄", mediator);
        landlord2.renting("龙岗区", 3400,70);
        landlord2.renting("龙岗区", 2800,50);

        Tenant tenant1 = new Tenant("张三",mediator);
        tenant1.renting("罗湖区", 1800, 25);
        Tenant tenant2 = new Tenant("李四",mediator);
        tenant2.renting("福田区", 3000, 25);

    }

}

1.2 中介者类的作用

1）中转作用（结构性）。通过中介者提供的中转作用，各个同事对象就不再需要显式地引用其他同事。当需要和其他同事进行通信时，可通过中介者来实现间接调用。

2）协调作用（行为性）。中介者可进一步对同事之间的关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做。中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理。将同事成员之间的关系行为进行分离和封装。

2 优缺点

优点：

1. 简化对象间交互；
2. 将各同事对象解耦，可以独立改变和复用每一个同事和中介者，增加新的中介者和同事类比较方便。

缺点：

1. 中介者类包含大量同事之间的交互细节，会使得具体中介者类非常复杂。

3 适用场景

1. 对象之间存在复杂的引用关系，系统结构混乱且难以理解。
2. 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。