Android源码设计模式学习笔记-中介者模式

写代码的过程一定会遇到这样的情况，有多个模块，互相都有关联，比如说现在做一个登陆界面，你的账号密码的输入情况和登录按钮是否可以点击有关联，当然还有可能有一个记住密码的复选框，同时又有关联到是否账号密码的编辑框为空。像这种多个模块互相都有关联的情况下，可以使用中介者模式去降低耦合性。中介者模式的Uml图如下:

image.png

下面我们来看一个实际使用中介者模式的栗子

image.png

我们电脑上有显示器，声卡，显卡，光驱，cpu等，它们其实不能直接通信，需要一个主板，这种情况下主板就是一个中介者，下面来以光驱播放视频为例来看看如何使用中介者模式实现.
抽象的被介绍者，相当于UML中的Colleague.

public abstract class Machine {
    protected Mediator mediator;

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

抽象的中介者

public abstract class Mediator {
    public abstract void changed(Machine machine);
}

光驱

public class CDDevice extends Machine{

    private String data;

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

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

    /**
     * 加载视频数据
     */
    public void load(){
        data = "视频数据,音频数据";
        mediator.changed(this);
    }
}

cpu用来解码数据和调用声卡和显卡播放

public class Cpu extends Machine{

    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[] tmp = data.split(",");
        dataVideo = tmp[0];
        dataSound = tmp[1];
        mediator.changed(this);
    }

}

显卡

public class GraphicsCard extends Machine{

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

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

声卡

public class SoundCard extends Machine{
    public SoundCard(Mediator mediator) {
        super(mediator);
    }

    public void soundPlay(String data){
        System.out.println("音频: "+data);
    }
}

主板类，作为中介者，协调光驱和cpu,声卡，显卡的运行过程.

public class MainBoard extends Mediator{
    private CDDevice cdDevice;
    private Cpu cpu;
    private SoundCard soundCard;
    private GraphicsCard graphicsCard;

    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;
    }

    @Override
    public void changed(Machine machine) {
        if (cdDevice == machine){
            handleCD(cdDevice);
        }else if (cpu == machine){
            handleCpu(cpu);
        }
    }

    private void handleCD(CDDevice cdDevice){
        cpu.decodeData(cdDevice.read());
    }

    private void handleCpu(Cpu cpu){
        soundCard.soundPlay(cpu.getDataSound());
        graphicsCard.videoPlay(cpu.getDataVideo());
    }
}

最终调用

public static void main(String[] args){
        MainBoard mainBoard = new MainBoard();
        CDDevice cd = new CDDevice(mainBoard);
        Cpu cpu = new Cpu(mainBoard);
        GraphicsCard graphicsCard = new GraphicsCard(mainBoard);
        SoundCard soundCard = new SoundCard(mainBoard);

        mainBoard.setCdDevice(cd);
        mainBoard.setCpu(cpu);
        mainBoard.setGraphicsCard(graphicsCard);
        mainBoard.setSoundCard(soundCard);

        cd.load();
}

上面我们看到，所有的被介绍者，包括Cpu和CDDevice通过MainBoard的changed回调整理整个运行流程，这个流程由开发者定，如果没有MainBoard这个中介者Cpu和CDDevice的耦合性势必会存在高耦合性.