《Android源码设计模式》之中介者模式

中介者模式介绍

中介者模式（Mediator Pattern）也称为调解者或调停者模式，所谓中介者模式就是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式的定义

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

中介者模式的使用场景

当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可采用中介者模式，来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

中介者模式的UML类图

根据类图我没可以得出如下一个中介者模式的通用模式代码。

抽象中介者

package com.guifa.patterndemo.mediatorpattern;

public abstract class Mediator {

    // 具体同事类A
    protected ConcreteColleagueA concreteColleagueA;
    // 具体同事类B
    protected ConcreteColleagueB concreteColleagueB;

    /**
     * 抽象中介方法、子类实现
     */
    public abstract void method();

    public void setConcreteColleagueA(ConcreteColleagueA concreteColleagueA) {
        this.concreteColleagueA = concreteColleagueA;
    }

    public void setConcreteColleagueB(ConcreteColleagueB concreteColleagueB) {
        this.concreteColleagueB = concreteColleagueB;
    }
}

具体中介者

package com.guifa.patterndemo.mediatorpattern;

public class ConcreteMediator extends Mediator {
    
    @Override
    public void method() {
        concreteColleagueA.action();

        concreteColleagueB.action();
    }
}

抽象同事

package com.guifa.patterndemo.mediatorpattern;

public abstract class Colleague {

    // 中介者对象
    protected Mediator mediator;

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

    /**
     * 同事角色的具体行为，由子类去实现
     */
    public abstract void action();
}

具体同事A

package com.guifa.patterndemo.mediatorpattern;

public class ConcreteColleagueA extends Colleague {

    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void action() {
        System.out.println("ConcreteA将信息递交给中介者处理");
    }
}

具体同事B

package com.guifa.patterndemo.mediatorpattern;

public class ConcreteColleagueB extends Colleague {

    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void action() {
        System.out.println("ConcreteB将信息递交给中介者处理");
    }
}

角色介绍：
Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。
ConcreteMediator：具体中介者角色，继承于抽象中介者，实现了父类定义的方法，它从具体的同事对象接收消息，向具体同事对象发出命令。
Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。
ConcreteColleagueA/B：具体同事类角色，继承与抽象同事类，每个具体同事类都知道本身在小范围内的行为，而不知道它在大范围内的目的。

中介者模式的简单实现

以电脑主机为例，主要由CPU、内存条、显卡、IO设备等组成，我没需要一样东西将这些零部件都整合起来变成一个完整的整体，这个东西就是主板，这里主板就起到了中介者的作用，连接CPU、内存条、显卡、IO设备等，任何两个模块之间的通信都会经过主板去协调，这里以读取光盘为例，来看看主板是如何充当这个中介者角色的。首先先定义一个抽象的中介者。

抽象中介者

package com.guifa.patterndemo.mediatorpattern;

public abstract class Mediator {
    
    /**
     * 同事对象改变时通知中介者的方法
     * 在同事对象改变时由中介者去通知其他的同时对象
     *
     * @param colleague colleague
     */
    public abstract void change(Colleague colleague);
}

抽象中介者中只是定义了一个抽象接口方法，具体的同事类通过该方法来通知中介者自身的状态改变。而具体的中介者这里就是指主板，由它负责联系各个具体同事类，也就是CPU、内存、显卡、IO设备等。

主板中介者

package com.guifa.patterndemo.mediatorpattern;

public class MainBoard extends Mediator {

    // 光驱设备
    private CDDevice cdDevice;
    // CPU
    private CPU cpu;
    // 声卡设备
    private SoundCard soundCard;
    // 显卡设备
    private GraphicsCard graphicsCard;

    @Override
    public void change(Colleague colleague) {
        if (colleague == cdDevice) {
            // 如果光驱读取了数据
            handleCD((CDDevice) colleague);
        } else if (colleague == cpu) {
            // 如果CPU处理完数据
            handleCPU((CPU) colleague);
        }
    }

    /**
     * 处理光驱读取数据后与其他设备的交互
     *
     * @param colleague 光驱设备
     */
    private void handleCD(CDDevice colleague) {
        cpu.decodeData(colleague.read());
    }

    /**
     * 处理CPU读取数据后与其他设备的交互
     *
     * @param colleague CPU
     */
    private void handleCPU(CPU colleague) {
        soundCard.soundPlay(colleague.getDataSound());
        graphicsCard.videoPlay(colleague.getDataVideo());
    }

    public void setCdDevice(CDDevice cdDevice) {
        this.cdDevice = cdDevice;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void setSoundCard(SoundCard soundCard) {
        this.soundCard = soundCard;
    }

    public void setGraphicsCard(GraphicsCard graphicsCard) {
        this.graphicsCard = graphicsCard;
    }
}

抽象同事类里只有一个抽象中介者的引用，我们再构造方法中为其赋值。

抽象同事

package com.guifa.patterndemo.mediatorpattern;

public abstract class Colleague {

    // 每一个同事都该知道其中介者
    protected Mediator mediator;

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

接下来就是各个具体的零部件了，首先是CPU，其负责从主板传递来音视频数据的解析。

CPU同事

package com.guifa.patterndemo.mediatorpattern;

public class CPU extends Colleague {

    // 视频数据
    private String dataVideo;
    // 音频数据
    private String dataSound;

    public CPU(Mediator mediator) {
        super(mediator);
    }

    /**
     * 获取视频数据
     *
     * @return 视频数据
     */
    public String getDataVideo() {
        return dataVideo;
    }

    /**
     * 获取音频数据
     *
     * @return 音频数据
     */
    public String getDataSound() {
        return dataSound;
    }

    public void decodeData(String data) {
        // 分割音、视频数据
        String[] tmp = data.split(",");
        // 解析音、视频数据
        dataVideo = tmp[0];
        dataSound = tmp[1];
        // 告诉中介者自身状态改变
        mediator.change(this);
    }
}

而CD设备则负责读取光盘的数据并将数据提供给主板。

光驱同事

package com.guifa.patterndemo.mediatorpattern;

public class CDDevice extends Colleague {

    // 视频数据
    private String data;

    public CDDevice(Mediator mediator) {
        super(mediator);
    }

    /**
     * 获取视频数据
     *
     * @return 视频数据
     */
    public String read() {
        return data;
    }

    /**
     * 加载视频数据
     */
    public void load() {
        // 实际情况中视频数据与音频数据都在一个数据流中
        data = "视频数据,音频数据";
        // 通知中介者，也就是主板数据改变
        mediator.change(this);
    }
}

显卡和声卡分别用来播放视频和音频，其逻辑相对来说简单。

显卡同事

package com.guifa.patterndemo.mediatorpattern;

public class GraphicsCard extends Colleague {

    public GraphicsCard(Mediator mediator) {
        super(mediator);
    }

    /**
     * 视频播放
     *
     * @param data 视频数据
     */
    public void videoPlay(String data) {
        System.out.println("视频" + data);
    }
}

声卡同事

package com.guifa.patterndemo.mediatorpattern;

public class SoundCard extends Colleague {

    public SoundCard(Mediator mediator) {
        super(mediator);
    }

    /**
     * 音频播放
     *
     * @param data 音频数据
     */
    public void soundPlay(String data) {
        System.out.println("音频" + data);
    }
}

最后，我们通过一个客户类来模拟电脑播放电影的效果。

客户类

package com.guifa.patterndemo.mediatorpattern;

public class Client {
    public static void main(String[] args) {
        // 构造主板对象
        MainBoard mainBoard = new MainBoard();

        // 构造各个零部件
        CDDevice cdDevice = new CDDevice(mainBoard);
        CPU cpu = new CPU(mainBoard);
        GraphicsCard graphicsCard = new GraphicsCard(mainBoard);
        SoundCard soundCard = new SoundCard(mainBoard);

        // 将各个零部件安装到主板
        mainBoard.setCdDevice(cdDevice);
        mainBoard.setCpu(cpu);
        mainBoard.setGraphicsCard(graphicsCard);
        mainBoard.setSoundCard(soundCard);

        // 完成后就可以开始播放了
        cdDevice.load();
    }
}

输出结果如下：

从上述程序演示读者可以明白，中介者模式就是用来协调多个对象之间的交互的，就像上面示例中的主板，如果没有主板中介者，那么电脑里的每一个零部件都要与其他零部件建立关联，比如CPU要与内存交互、CPU要与显卡交互等，这么一来就会构成一个错综复杂的网状图，而中介者模式的出现则是将这一个错综复杂的网状图变成一个结构清晰的星形图，而中心就是中介者。

总结

在面向对象的编程语言里，一个类必然会与其他类产生依赖关系，如果这种依赖关系如网状错综复杂，那么必然会影响我们的代码逻辑以及执行效率，适当地使用中介者模式可以对这种依赖关系进行解耦使逻辑结构清晰，但是，如果几个类间的依赖关系并不复杂，使用中介者模式反而会使得原本不复杂的逻辑结构变得复杂，所有，我没在决定使用中介者模式之前要多方考虑、权衡利弊。