0x1、定义
原始定义
定义一个单独对象(中介)来封装一组对象间的交互，将这组对象间的交互委派给中介对象，来避免对象间的直接交互。
定义简单明了，就是：
用中介对象来处理对象间的直接交互，封装多个对象间的交互细节。
举个例子，在房产中介还没出来前，房东与租客间的关系是这样的(多对多的网状关系)：
网络异常，图片无法展示
|
而中介出现后 (一对多的星状关系)：
网络异常，图片无法展示
|
从原先的房东直接跟租户直接交互变成了，房东跟中介对接，租客也跟中介对接。
0x2、写个简单例子
以上面的房屋中介为例，先是 抽象组件类 → 定义组件需要执行的方法操作；
public abstract class People { protected String name; protected Mediator mediator; // 每个人都知道中介 public People(String name, Mediator mediator) { this.name = name; this.mediator = mediator; } // 要执行的方法操作 abstract void sendMessage(String msg); abstract void receiveMessage(String msg); }
接着是 抽象中介类 → 定义中介要执行的方法操作，
public interface Mediator { void contact(People from, String msg); }
再接着是 具体组件类 → 继承抽象组件类，实现相关方法，不了解其他组件的状况，但都认识中介对象：
// 房东 public class Landlord extends People { private String demand; public Landlord(String name, Mediator mediator, String demand) { super(name, mediator); this.demand = demand; } public String getDemand() { return demand; } @Override void sendMessage(String msg) { System.out.println("【房东】" + name + "给中介发送消息: " + msg); mediator.contact(this, msg); } @Override void receiveMessage(String msg) { System.out.println("【房东】" + name + "收到消息: " + msg); } } // 租客 public class Tenant extends People { public Tenant(String name, Mediator mediator) { super(name, mediator); } @Override void sendMessage(String msg) { System.out.println("【租客】" + name + "给中介发送消息: " + msg); mediator.contact(this,msg); } @Override void receiveMessage(String msg) { System.out.println("【租客】" + name + "收到消息: " + msg); } }
再接着是 具体中介类 → 实现相关方法，需要知道所有具体组件，并从具体组件接收消息，并向具体组件发送消息。
public class HouseMediator implements Mediator { // 中介知道所有组件 private final Map<String, Landlord> landlords = new HashMap<>(); private final Map<String, Tenant> tenants = new HashMap<>(); public void putLandlord(Landlord landlord) { landlords.put(landlord.name, landlord); } public void putTenant(Tenant tenant) { tenants.put(tenant.name, tenant); } @Override public void contact(People from, String msg) { if(from instanceof Landlord) { for (Tenant tenant: tenants.values()) { tenant.receiveMessage("有房东发布了新房源：" + ((Landlord)from).getDemand()); } } else { for(Landlord landlord: landlords.values()) { if (msg.contains(landlord.getDemand())) { System.out.println("租客" + from.name + "对" + landlord.getDemand() + "的房源感兴趣，通知下房东~"); landlord.receiveMessage("有人对您发布的房源感兴趣~"); } } } } }
最后是测试用例
public class Client { public static void main(String[] args) { // 实例化中介实例 HouseMediator mediator = new HouseMediator(); // 实例化组件对象 Landlord landlord1 = new Landlord("包租婆", mediator, "两室一厅"); Landlord landlord2 = new Landlord("包租公", mediator, "三室一厅"); mediator.putLandlord(landlord1); mediator.putLandlord(landlord2); Tenant tenant1 = new Tenant("杰哥", mediator); Tenant tenant2 = new Tenant("阿伟", mediator); Tenant tenant3 = new Tenant("彬彬", mediator); mediator.putTenant(tenant1); mediator.putTenant(tenant2); mediator.putTenant(tenant3); // 与中介实例交互 landlord1.sendMessage("想出租下两室一厅，帮我找些租客"); tenant1.sendMessage("我想租下两室一厅，有房源推荐吗？"); } }
代码运行结果输出如下：
网络异常，图片无法展示
|
租客和房东间不直接交互，都是通过中介写上进行，很好理解，带出一波UML类图：
网络异常，图片无法展示
|
适用场景
- 参与者间交互关系错综复杂，维护成本很高时，才考虑使用中介模式；
- 解决对象间的直接耦合问题，通过中介来中转；
- 想定义一个分布在多个类中的行为，又不想生成太多的子类；
优点
- 松散耦合，减少对象间的直接交互，减少子类创建数量；
- 集中控制交互，简化系统设计与实现，新建中间层快速扩展功能，提升代码扩展性；
缺点
- 过度集中化，容易产生大而复杂的上帝类，维护成本变高；
- 中介对象需要知道所有对象的交互逻辑，增加了学习成本；
0x3、加餐：外观模式 vs 代理模式 vs 观察者模式 vs 中介模式
- 外观模式 → 结构型设计模式，对子系统提供统一接口，单向，所有请求都委托子系统完成，树形结构。
- 代理模式 → 结构型设计模式，引用代理对象的方式来访问目标对象，单向；
- 观察者模式 → 行为型设计模式，一般来说参与者间的关系比较有条理，交互关系往往是单向的，参与者要么是观察者，要么是被观察者；
- 中介模式 → 行为型设计模式，参与者间的关系比较复杂，参与者既可以是观察者，也可以是被贯彻着，双向；
