十六、 中介者设计模式

1. 中介者设计模式介绍

• 用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用，从而使耦合松散，而且可以独立地改变它们之间的交互。

• 中介设计模式将对象之间多对多关系变成一对多的关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

2. 中介者设计模式使用场景

• 当对象之间的交互操作很多而且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的同时，同时涉及修改很多其它对象的行为，可以采用中介者模式。

3. 中介者设计模式UML类图

角色介绍：

• Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口。

• ConcreteMediator:具体中介者角色，继承与抽象中介者，实现了父类定义的方法，它从具体的同事类对象接收消息，向具体同事对象发出命令。

• Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者 而不知道其它的同事类对象。

• ConcreteColleagueA/B:具体同事类，继承于抽象同事类，每个具体同事类都知道本身在小范围的行为，而不知道它在打范围的目的。

4. 中介者设计模式简单实现

情景如下：
我们知道电脑主机部分主要分为以下几块：CPU、内存、显卡、IO设备。但是每个独立的部件是不能单独运行的，我们需要主板将这些部件整合起来，这里的主板就起到了中介者的作用。任意两个模块之间都可以通过主板进行通信。

• (1)、抽象中介者：Mediator

public abstract class Mediator {

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

抽象中介中定义了一个抽象接口方法，具体的Colleague类通过该方法来通知中介者自身的状态改变。

• (2)、主板中介者:

public class MainBorad extends Mediator {
    private CDDevice cdDevice;//光驱设备
    private CPU cpu;//CPU
    private SoundCard soundCard;//声卡设备
    private GraphicsCard graphicsCard;//显卡设备

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

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

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

    /**
     * 设置CD设备
     *
     * @param cdDevice
     */
    public void setCdDevice(CDDevice cdDevice) {
        this.cdDevice = cdDevice;
    }

    /**
     * 设置CPU
     *
     * @param cpu
     */
    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    /**
     * 声卡设备
     *
     * @param soundCard
     */
    public void setSoundCard(SoundCard soundCard) {
        this.soundCard = soundCard;
    }

    /**
     * 设置声卡
     *
     * @param graphicsCard
     */
    public void setGraphicsCard(GraphicsCard graphicsCard) {
        this.graphicsCard = graphicsCard;
    }
}

• (3)、抽象Colleague类

public abstract class Colleague {

    protected Mediator mediator;

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

在抽象Colleague类中有一个抽象中介者的引用。

• (4)、各个具体的零部件，CPU,CD,GraphicsCard，SoundCard

CPU:

public class CPU extends Colleague {
    private String dataVedio, dataSound;//视频和音频数据

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

    public String getDataVedio() {
        return dataVedio;
    }

    public String getDataSound() {
        return dataSound;
    }

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

CDDevice:

public class CDDevice extends Colleague {
    private String data;//视频数据

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

    public String read() {
        return data;
    }

    /**
     * 加载视频数据
     */
    public void load() {
        data = "视频数据,音频数据";
        //通知中介者,也就是主板数据发生改变
        mediator.changed(this);
    }
}

• GraphicsCard:

public class GraphicsCard extends Colleague {

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

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

}

• SoundCard:

public class SoundCard extends Colleague {

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

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

• 测试类：

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

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

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

        //安装完以后一可以开始放片了
        cdDevice.load();
    }
}

下面我们来说一下上面的流程：

首先，每个部件里面都有一个主板引用 ，这样各个部件就可以和主板进行通信；主板里面通过set方法将各个主板部件引用传递进去，这样主板就可以各个部件进行通信。

下面说Client里面的流程：

• (1). cdDevice.load()，CD部件调用load方法，加载数据，通知主板数据读取了，同时将自身对象传递进去：

public void load() {
        data = "视频数据,音频数据";
        //通知中介者,也就是主板数据发生改变
        mediator.changed(this);
}

• (2)、此时我们进入到了主板的change方法里面：

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

由于刚刚是从CDDevice对象里面传递进来的，所以调用handleCd()，下面是handleCd的方法：

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

handleCd方法里面调用cpu的decodeData()方法，同时将CDDevice部件读取的数据传递给cpu对象。

• (4)、下面我们进入cpu对象里面，查看器decodeData()方法：

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

在cpu的decode方法里面，处理完数据后，CPU又通知主板数据发生了改变，同时将自身对象传递进去。

• (5)、在主板类中，当主板收到了来自cup的数据改变消息时，调用handleCPU方法：

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

在handleCPU方法中，由调用了声卡和显卡来处理数据：

private void handleCPU(CPU cpu) {
    soundCard.soundPlay(cpu.getDataSound());
    graphicsCard.vedioPlay(cpu.getDataVedio());
}

• (6)、声卡，显卡分别对传递进来的数据进行相应的处理：

声卡：

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

显卡：

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

5.总结

• 优点：简化了对象的交互，由原来多对多的关系，变成了多对一的关系。

• 缺点：如果几个类间的依赖关系并不复杂，使用中介者模式反而会使原本不复杂的逻辑结构变得复杂。