一 定义
中介者模式也称为调停者模式或者调解者模式，在生活中比较常见的房地产中介，房地产中介在买房者和卖房者中间建立起一座桥梁，买家和卖家通过中介来了解各自的需求，可能如果不到交易阶段，买家和卖家都不会见面。
定义：中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。
中介者的本质，封装交互。
二 模式结构
角色介绍：
- Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。
- ConcreteMediator：具体的中介者角色，继承自抽象中介者，实现了抽象中介者中定义的方法，从具体同事对象中接收消息，向具体的同事对象发出命令。
- Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。
- ConcreteColleagueA/B：具体同事类角色，继承自抽象同事类。
三 实例
通用代码：
- 抽象中介者
public abstract class Mediator {
protected ConcreteColleagueA mConcreteColleagueA;
protected ConcreteColleagueB mConcreteColleagueB;
/**
* 抽象的中介方法，由子类实现
*/
public abstract void method();
public void setConcreteColleagueA(ConcreteColleagueA concreteColleagueA) {
mConcreteColleagueA = concreteColleagueA;
}
public void setConcreteColleagueB(ConcreteColleagueB concreteColleagueB) {
mConcreteColleagueB = concreteColleagueB;
}
}
- 具体中介者
public class ConcreteMediator extends Mediator{
@Override
public void method() {
mConcreteColleagueA.action();
mConcreteColleagueB.action();
}
}
- 抽象同事
public abstract class Colleague {
protected Mediator mMediator; // 中介者对象
public Colleague(Mediator mediator){
this.mMediator=mediator;
}
/**
* 同事的具体行为，由子类去实现
*/
public abstract void action();
}
- 具体同事
public class ConcreteColleagueA extends Colleague{
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
@Override
public void action() {
System.out.println("ColleagueA将信息传递给中介者处理");
}
}
public class ConcreteColleagueB extends Colleague{
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
@Override
public void action() {
System.out.println("ColleagueB将信息传递给中介者处理");
}
}
- 测试代码
// 构造中介者
ConcreteMediator concreteMediator=new ConcreteMediator();
// 构造两个同事
ConcreteColleagueA concreteColleagueA=new ConcreteColleagueA(concreteMediator);
ConcreteColleagueB concreteColleagueB=new ConcreteColleagueB(concreteMediator);
// 为中介者设置同事
concreteMediator.setConcreteColleagueA(concreteColleagueA);
concreteMediator.setConcreteColleagueB(concreteColleagueB);
// 执行中介方法
concreteMediator.method();
下面，我们以具体的实例分析，我们以房子的交易流程为例。现在我们有很多app都是专门的房屋交易app，买家和卖家在app上注册，注册完成以后，买家和卖家是不能直接进行交流的，这时需要一个房地产的中介，买家可以就感兴趣的房子向中介咨询，中介接收到信息以后，如果不能确定的，就去找卖家咨询，然后再转发给买家，最终在中介的参与下完成交易。具体代码如下：
- 抽象的客户类
定义了一个客户基本的方法，如注册，发送消息，接收消息等。
public abstract class Customer {
protected HouseMediator mHouseMediator; // 持有一个中介者对象
public Customer(HouseMediator houseMediator){
this.mHouseMediator=houseMediator;
}
//注册
public abstract void register();
//发送消息
public abstract void sendMes();
//接收消息
public abstract void receiverMsg();
//接收消息
public abstract void action();
}
- 具体的客户
public class CustomerBuyer extends Customer {
public CustomerBuyer(HouseMediator houseMediator) {
super(houseMediator);
}
@Override
public void register() {
System.out.println("注册为买家-小明");
}
@Override
public void sendMes() {
System.out.println("买家咨询房子的信息");
}
@Override
public void receiverMsg() {
System.out.println("买家接收房子的信息");
}
@Override
public void action() {
System.out.println("买家付钱");
}
}
public class CustomerSeller extends Customer {
public CustomerSeller(HouseMediator houseMediator) {
super(houseMediator);
}
@Override
public void register() {
System.out.println("注册为卖家-小华");
}
@Override
public void sendMes() {
System.out.println("卖家咨发送房子的信息");
}
@Override
public void receiverMsg() {
System.out.println("卖家接收房子的咨询信息");
}
@Override
public void action() {
System.out.println("卖家收钱");
}
}
- 抽象的中介者
public abstract class HouseMediator {
protected CustomerBuyer mCustomerBuyer; // 买家对象
protected CustomerSeller mCustomerSeller; // 卖家对象
/**
* 抽象的中介方法，模拟房子的交易过程，由子类实现
*/
public abstract void method();
public void setCustomerBuyer(CustomerBuyer customerBuyer) {
mCustomerBuyer = customerBuyer;
}
public void setCustomerSeller(CustomerSeller customerSeller) {
mCustomerSeller = customerSeller;
}
}
- 具体的中介者
public class LianJiaHouseMediator extends HouseMediator{
@Override
public void method() {
mCustomerBuyer.register();
mCustomerSeller.register();
mCustomerBuyer.sendMes();
mCustomerSeller.receiverMsg();
mCustomerSeller.sendMes();
mCustomerBuyer.receiverMsg();
mCustomerBuyer.action();
mCustomerSeller.action();
}
}
- 测试代码
// 构造链家的房地产中介
LianJiaHouseMediator lianJiaHouseMediator=new LianJiaHouseMediator();
// 构造买家和卖家
CustomerBuyer buyer=new CustomerBuyer(lianJiaHouseMediator);
CustomerSeller seller=new CustomerSeller(lianJiaHouseMediator);
// 为买家和卖家设置中介
lianJiaHouseMediator.setCustomerBuyer(buyer);
lianJiaHouseMediator.setCustomerSeller(seller);
// 模拟交易过程
lianJiaHouseMediator.method();
-
运行结果
四 优缺点
优点：减少了类之间的依赖，同事类只依赖于中介，降低了类之间的耦合。
缺点：如果同事类过多，因为同事类依赖中介，会造成中介者膨胀很大，逻辑会很复杂。
使用场景：中介者模式适用于多个对象存在紧密耦合的情况。
