中介者模式（集中相关对象之间复杂的沟通和控制方式）

源码地址	https://github.com/DingMouRen/DesignPattern

中介者模式.png

• Mediator 抽象中介者 定义了同事对象到中介者对象的接口，以抽象类的方式实现
• ConcreteMediator 具体中介者，从具体同事对象接收消息，向具体同事对象发出命令。
• Colleague 抽象同事类 定义中介者对象的接口，只知道中介者，但是不知道其他同事对象
• Colleague 具体同事类，只知道自身的行为，将信息交给具体中介者

协作

具体同事向一个具体中介者发送和接收请求，具体中介者在各个具体同事之间适当的转发请求来实现协作行为。

举个栗子

电脑的主板就是一个中介者模式的例子，主板协调光驱CDDevice CPU
GraphicsCard SoundCard一起工作。

//抽象中介者
public abstract class Mediator {
    //同事对象改变时通知中介者的方法，在同事对象改变时由中介者去通知其他的同事对象
    public abstract void changed(Colleague colleague);
}
//具体中介者  主板负责将CPU 显卡  声卡集合到一起，负责它们之间的联系
public class MainBoard extends Mediator {
    private CDDevice cdDevice;//光驱
    private CPU cpu;
    private SoundCard soundCard;//声卡
    private GraphicsCard graphicsCard;//显卡
    @Override
    public void changed(Colleague colleague) {
        //如果光驱加载完数据，就处理CD,如果是cpu，就处理cpu
        if (colleague == cdDevice){
            handleCD(cdDevice);
        }else if (colleague == cpu){
            handleCPU((CPU) colleague);
        }
    }

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

    //处理cpu读取的数据后，再与其他设备交互
    private void handleCPU(CPU cpu){
        soundCard.soundPlay(cpu.getDataSound());
        graphicsCard.videoPlay(cpu.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;
    }
}

//抽象同事
public abstract class Colleague {
    protected Mediator mediator;//每一个同事类都有中介者的引用

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}
//具体同事  光驱负责读取光盘数据并将数据提供给主板
public class CDDevice extends Colleague {
    private String data;//光盘上的数据
    public CDDevice(Mediator mediator) {
        super(mediator);
    }

    //加载视频数据
    public void load(){
        data = "视频数据,音频数据";
        //数据已经加载完毕，通知中介者，主板数据改变
        mediator.changed(this);
    }

    //读取视频数据
    public String read(){
        return data;
    }
}
//具体同事类 ： cpu
public class CPU extends Colleague {
    private String dataVideo,dataSound;//视频和音频数据
    public CPU(Mediator mediator) {
        super(mediator);
    }

    //解码数据
    public void decodeData(String data){
        String[] tmp = data.split(",");
        dataVideo = tmp[0];
        dataSound = tmp[1];
        //数据解析结束后，向中介者发送请求，通知中介者
        mediator.changed(this);
    }

    public String getDataVideo() {
        return dataVideo;
    }

    public String getDataSound() {
        return dataSound;
    }
}
//具体同事类  声卡用来播放音频
public class SoundCard extends Colleague {
    public SoundCard(Mediator mediator) {
        super(mediator);
    }
    //播放音频
    public void soundPlay(String dataSound){
        System.out.println(getClass().getSimpleName()+"播放"+dataSound);
    }
}

使用

    public static void main(String[] args) {
        //构造主板：具体中介者
        MainBoard mediator = new MainBoard();
        //分别构造其他的部件
        CDDevice cdDevice = new CDDevice(mediator);
        CPU cpu = new CPU(mediator);
        GraphicsCard graphicsCard = new GraphicsCard(mediator);
        SoundCard soundCard = new SoundCard(mediator);
        //将部件设置到主板，分别与中介者创建联系
        mediator.setCdDevice(cdDevice);
        mediator.setCpu(cpu);
        mediator.setGraphicsCard(graphicsCard);
        mediator.setSoundCard(soundCard);
        //只要开始加载数据，具体中介者主板就可以协调它们来工作
        cdDevice.load();
    }

总结

在编程中，一个类必然会与其他类产生依赖关系，如果这种依赖关系如网状般复杂的话，一定会影响我们代码的逻辑以及执行效率。可以通过中介者模式对这种复杂的依赖关系进行解耦，让逻辑结构变得清晰。