《Android源码设计模式解析与实战》读书笔记（十七）——中介者模式

中介者模式也成为调解者模式或调停者模式， Mediator 本身就有调停者和调解者的意思。一般我们听“中介”这个词听得最多的莫过于房产中介了，房产中介者的职责就是作为买房者和卖房者之间的桥梁帮忙联系沟通，其实买房者和卖房者的直接接触很少，大多数情况都是通过房产中介者来传达信息的。房产中介者负责协调的无非也就买房者和卖房者两类对象，但是 Android 的中介者模式需要协调的是多类对象，以做一个 App 为例，做一个 App 基本上需要运维、产品、开发、设计还有测试，准备做的时候需要先开个会讨论想做成什么样，然后运维会说用户倾向怎么怎么样，开发会说用户反映界面不好看怎么怎么样等等等等，每个人说的话基本都是先从自己的立场出发的，这样基本讨论不出什么结果，这时候如果有一个既不是运维，也不是产品、开发、设计、测试的人，大家把各自的意见都先汇报给这个人，然后这个人再权衡利弊，最终做出决定，不论是什么决定，下面的人直接执行就好了，这样一个方案基本上很快就能出来，这个人也就是所谓的产品经理，我们也称为中介者，他面对的就是多类对象。

第十七章 "和事佬"——中介者模式

1.定义

中介者模式包装了一系列对象相互作用的方式，使这些对象不必相互明显作用，从而让它们松耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些对象可以彼此独立变化。中介者模式将多对多的相互作用转化为一对多的相互作用。

2.使用场景

1）.当对象之间的交互操作很多并且每个对象的行为都依赖彼此时，为了防止在修改一个对象的行为时涉及到修改很多其他对象的行为，可采用中介者模式，解决紧耦合问题。

3.简单实现

同样先看看中介者模式有哪些角色。

Mediator：抽象中介者，定义同事对象到中介者对象的接口，一般为抽象类。

ConcreteMediator：具体中介者，实现父类方法，从具体同事对象接收消息，又向其他的具体同事对象发送命令。

Colleague：抽象同事类，它只知道中介者而不知道其他同事对象。

ConcreteColleague：具体同事类，每个具体同事类知道自身小范围内的行为，不知道大范围的目的。

假设一个场景，各国之间需要贸易，但是如果每个国家都得自己去联系就太麻烦了，每个国家都得跑，于是我们设立一个联合国，需要发起贸易的时候向联合国提出请求，并告知要贸易的对象，联合国再去通知贸易对象，这样就不必每个国家都去联系，你只需要联系联合国，然后剩下的事联合国再去帮你联系。

抽象中介者需要有一个方法通知其他同事：

public abstract class Mediator {
    public abstract void mediate(Country country, int money);
}

具体中介者（联合国），持有其他所有同事引用，并根据是谁发起的请求作出具体操作：

public class TheUnitedNations extends Mediator {
    private America america;
    private China china;
    private England england;
    private Japan japan;
    private Russia russia;

    public void setAmerica(America america) {
        this.america = america;
    }

    public void setChina(China china) {
        this.china = china;
    }

    public void setEngland(England england) {
        this.england = england;
    }

    public void setJapan(Japan japan) {
        this.japan = japan;
    }

    public void setRussia(Russia russia) {
        this.russia = russia;
    }

    @Override
    public void mediate(Country country, int money) {
        if (country == america) {
            china.receiveTrade(money);
            england.receiveTrade(money);
            japan.receiveTrade(money);
            russia.receiveTrade(money);
        } else if (country == china) {
            england.receiveTrade(money);
            russia.receiveTrade(money);
        } else if (country == england) {
            china.receiveTrade(money);
        } else if (country == japan) {
            america.receiveTrade(money);
        } else if (country == russia) {
            china.receiveTrade(money);
        }
    }
}

抽象同事类（国家），需要持有中介者的实例：

public abstract class Country {
    Mediator mediator;

    public Country(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void requestTrade(int money);

    public abstract void receiveTrade(int money);

}

具体同事类（每一个国家），都类似，只列举一个：

public class America extends Country {
    public America(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void requestTrade(int money) {
        mediator.mediate(this, money);
    }

    @Override
    public void receiveTrade(int money) {
        System.out.println("America 收到了金额为" + money + "的贸易请求");
    }
}

客户端调用：

        TheUnitedNations mTheUnitedNations = new TheUnitedNations();

        America mAmerica = new America(mTheUnitedNations);
        China mChina = new China(mTheUnitedNations);
        England mEngland = new England(mTheUnitedNations);
        Japan mJapan = new Japan(mTheUnitedNations);
        Russia mRussia = new Russia(mTheUnitedNations);
        
        mTheUnitedNations.setAmerica(mAmerica);
        mTheUnitedNations.setChina(mChina);
        mTheUnitedNations.setEngland(mEngland);
        mTheUnitedNations.setJapan(mJapan);
        mTheUnitedNations.setRussia(mRussia);

        mAmerica.requestTrade(49999999);

运行后打印如下：

可以看到美国发起了贸易请求，其他四个国家都收到了，但是美国并没有和其他四个国家紧耦合，所有国家都只和中介者有联系。

4.总结

中介者模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状结构变成以中介者为中心的星形结构，降低系统复杂性，提高可扩展性。在面向对象的编程语言中，一个类必然会与其他类产生依赖，如果这种依赖关系如网状般错综复杂，那么逻辑就会很混乱，适当使用中介者模式可以解开这种紧耦合，使逻辑清晰。但是如果几个类之间的依赖关系并不复杂的话，中介者模式反而会使不复杂的逻辑变得复杂，所以使用时需多方考虑。

Demo下载