中介者模式

一 定义

中介者模式也称为调停者模式或者调解者模式，在生活中比较常见的房地产中介，房地产中介在买房者和卖房者中间建立起一座桥梁，买家和卖家通过中介来了解各自的需求，可能如果不到交易阶段，买家和卖家都不会见面。

定义：中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

中介者的本质，封装交互。

二 模式结构

角色介绍：

• 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();

• 运行结果

  
  

四 优缺点

优点：减少了类之间的依赖，同事类只依赖于中介，降低了类之间的耦合。
缺点：如果同事类过多，因为同事类依赖中介，会造成中介者膨胀很大，逻辑会很复杂。

使用场景：中介者模式适用于多个对象存在紧密耦合的情况。