设计模式 --- 中介者模式

1.定义

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

2.使用场景

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

3.简单实现

以计算机读取光盘为例。计算机的主板连接了CPU、内存、显卡、IO设备等，任何两个模块通信都是通过主板来协调，这里的主板就是相当于中介者的作用。

//抽象同事对象
abstract class Colleague{
    protected  Mediator mediator; //每个同事对象都知道中介者
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
}

//CPU 负责将主板传过来的音视频解码
class CPU extends Colleague{

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

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

    public String getDataVideo() {
        return dataVideo;
    }

    public String getDataSound() {
        return dataSound;
    }

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

//CD设备 负责读取数据
class CDDevice extends Colleague{

    private String data;

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

    //读取数据
    public String read(){
        return data;
    }

    //加载数据
    public void load(){
        data = "视频数据data,音频数据data"; //模拟数据
        //通知中介者
        mediator.change(this);
    }

}

//显卡 负责显示视频数据
class GraphicsCard extends Colleague{

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

    public void showVideo(String data){
        System.out.println("视频显示：" + data);
    }
}

//声卡 负责音频播放
class SoundCard extends Colleague{

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

    public void palySound(String data){
        System.out.println("音频播放：" + data);
    }
}

//抽象中介者
abstract class Mediator{
    //同事对象改变时通知中介者方法
    //再由中介者通知其它人
    abstract void change(Colleague colleague);
}

//主板
class MainBoard extends Mediator{
    private CPU cpu;
    private CDDevice cdDevice;
    private GraphicsCard graphicsCard;
    private SoundCard soundCard;

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

    //处理cd取得数据后与其他设备的交互
    private void handleCD(CDDevice c){
        //交由CPU解码
        cpu.decodeData(c.read());
    }

    //处理CPU处理完数据后与其他设备的交互
    private void handleCPU(CPU cpu){
        //交给显卡显示视频
        graphicsCard.showVideo(cpu.getDataVideo());
        //交给声卡播放音频
        soundCard.palySound(cpu.getDataSound());
    }

    public CPU getCpu() {
        return cpu;
    }

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

    public CDDevice getCdDevice() {
        return cdDevice;
    }

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

    public GraphicsCard getGraphicsCard() {
        return graphicsCard;
    }

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

    public SoundCard getSoundCard() {
        return soundCard;
    }

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

public class MediatorMaode {
    public static void main(String[] args){
        //构建一个主板
        MainBoard mainBoard = new MainBoard();
        //创建各种设备
        CPU cpu = new CPU(mainBoard);
        CDDevice cdDevice = new CDDevice(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();
    }
}

输出：

4.小结

如果依赖关系如网状比较复杂，可以考虑使用中介者模式进行解耦，但是如果几个类之间的依赖关系并不复杂，使用中介者模式反而会使逻辑结构变得复杂。