基础知识(08) -- 中介者模式

思维导图

----------------------------------------------------------------------

1、场景问题                                                           

　大家都知道电脑的主要配件有：CPU、内存、硬盘、显卡、声卡、网卡、光驱、主板等，这些配件它们之间都是通过主板来完成相互之间的交互工作，但是如果没有了主板会怎么样呢？

　　如果没有了主板情况，那么各个配件之间就需要自行相互交互，以相互传送数据，如下图：

　　如果有主板的情况，各个配件的交互完全通过主板来完成，每个配件都只需要和主板交互，而主板知道如何和所有的配件交互，如下图：

　　如果上面的情况发生在软件开发中呢？ 就相当于出现了多个类之间相互交互，而且交互的很频繁，导致每个类都必须知道所有需要交互的类，也就是我们常说的类和类耦合了，是不是很麻烦？那该如何来简化这种多个对象之间的交互呢？ ----> 使用中介者模式来解决。

演示案例：程序模拟用电脑来看电影，简化后的流程如下：

　　第一步：首先是光驱要读取光盘上的数据，然后告诉主板，它的状态改变了

　　第二步：主板去得到光驱的数据，把这些数据交给CPU进行分析处理

　　第三步：CPU处理完后，把数据分成了视频数据和音频数据，通知主板，它处理完了

　　第四步：主板去得到CPU处理过后的数据，分别把数据交给显卡和声卡，去显示出视频和发出声音

上面的流程是持续的、不断重复的直到电影播放完毕，下面使用程序把这个过程实现出来：

2、解决方案 --- 使用中介者模式来解决问题                              

2.1 中介者模式的定义：

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

2.2 使用中介者模式来解决问题的思路：

　　通过分析上面的问题，根本原因就在于多个对象需要相互交互，从而导致对象之间紧密耦合，不利于对象的修改和维护。

　　使用中介者模式解决问题的思路很简单，中介者模式通过引入一个中介者对象，让其他的对象都只和中介对象交互，而中介对象知道如何和其他所有的对象交互，这样对象之间的依赖关系就没有了，从而实现了对象之间的解耦。（对于中介对象而言，所有相互交互的对象，被视为同事类；中介对象就是来维护各个同事之间的关系，而所有的同事类都只是和中介对象交互。）

2.3 中介者模式的结构和说明：

　　

说明：

　　Mediator: 中介者接口。在里面定义各个同事之间交互需要的方法。

　　ConcreteMediator： 具体中介者实现对象。它需要了解并维护各个同事对象，并肩负具体的协调各同事对象的交互关系。

　　Colleague: 同事类的定义，通常实现成为抽象方法，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能。

　　ConcreteColleague: 具体的同事类，实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同事交互。

中介者模式的示例代码：

/**
 * 同事类的抽象父类  5  */
public abstract class Colleague {

    //持有中介者对象,每一个同事类都知道它的中介者对象
    private Mediator mediator;
    
    /**
     * 构造方法,传入中介者对象
     * @param mediator
     */
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    /**
     * 获取当前同事类对应的中介者对象
     * @return
     */
    public Mediator getMediator() {
        return mediator;
    }
}

/**
 * 具体的同事类A
 */
public class ConcreteColleagueA extends Colleague {

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

    /**
     * 示意方法，执行某些业务功能
     */
    public void someOperation(){
        //在需要跟其他同事通信的时候，通知中介者对象
        getMediator().change(this);
    }
}

/**
 * 具体的同事类B
 */
public class ConcreteColleagueB extends Colleague {

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

    /**
     * 示意方法，执行某些业务功能
     */
    public void someOperation(){
        //在需要跟其他同事通信的时候，通知中介者对象
        getMediator().change(this);
    }
}


/**
 * 中介者，定义各个同事对象通信的接口
 */
public interface Mediator {
    /**
     * 同事对象在自身改变的时候来通知中介者的方法
     * 让中介者去负责相应的与其他同事对象的交互
     * @param colleague 同事对象自身
     */
    public void change(Colleague colleague);
}

/**
 * 具体的中介者实现 81  */
public class ConcreteMediator implements Mediator {

    //持有并维护同事A
    private ConcreteColleagueA colleagueA;
    
    //持有并维护同事B
    private ConcreteColleagueB colleagueB;
    
    public ConcreteMediator() {
    }

    @Override
    public void change(Colleague colleague) {
        //某个同事类发生了变化，通常需要与其他同事交互
        //具体协调相应的同事对象来实现协作行为
    }
    
    /**
     * 设置中介者需要了解并维护的同事A对象
     * @param colleagueA 同事A对象
     */
    public void setColleagueA(ConcreteColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    /**
     * 设置中介者需要了解并维护的同事B对象
     * @param colleagueB 同事B对象
     */
    public void setColleagueB(ConcreteColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }
}

 使用中介模式来描述电脑看电影的流程：

/**
 * 所有同事的抽象父类
 */
public abstract class Colleague {
    private Mediator mediator;
    
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

    public Mediator getMediator() {
        return mediator;
    }
}

/**
 * 同事类： 光驱类
 */
public class CDDriver extends Colleague {
    //光驱读取出来的数据
    private String data = "";
    
    public CDDriver(Mediator mediator) {
        super(mediator);
    }
    
    /**
     * 读取光盘
     */
    public void readCD(){
        this.data = "学习研磨设计模式,中介者模式";
        //通知主板，自己的状态发生了改变
        this.getMediator().changed(this);
    }

    public String getData() {
        return data;
    }
}

/**
 * 同事类： CPU
 */
public class CPU extends Colleague{
    //分析出来的视频数据
    private String videoData = "";
    //分析出来的音频数据
    private String soundData = "";
    
    public CPU(Mediator mediator) {
        super(mediator);
    }
    
    /**
     * 处理数据，把数据 分成音频和视频的数据
     * @param data
     */
    public void executeData(String data){
        //把数据分解开，前面的是视频数据，后面的是音频数据
        String[] ss = data.split(",");
        this.videoData = ss[0];
        this.soundData = ss[1];
        
        //通知主板，CPU的工作完成了
        this.getMediator().changed(this);
    }

    public String getVideoData() {
        return videoData;
    }

    public String getSoundData() {
        return soundData;
    }
}

/**
 * 同事类 ： 显卡类
 */
public class VideoCard extends Colleague {

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

    /**
     * 显示视频数据
     * @param data 被显示的数据
     */
    public void showData(String data){
        System.out.println("您正观看的是 : " + data);
    }
}

/**
 * 同事类: 声卡类
 */
public class SoundCard extends Colleague {

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

    /**
     * 按照声频数据发出声音
     */
    public void soundData(String data){
        System.out.println("画外音: " + data);
    }
}

/**
 * 中介者对象的接口
 */
public interface Mediator {
    /**
     * 同事对象在自身改变的时候来通知中介者的方法，
     * 让中介者去负责相应的与其他同事对象的交互
     * @param colleague 同事对象自身，好让中介者对象通过对象实例去获取同事对象的状态
     */
    public void changed(Colleague colleague);
}

/**
 * 主板类，实现中介者接口
 */
public class MediatorBoard implements Mediator {

    //需要知道要交互的同事类--光驱类
    private CDDriver cdDriver = null;
    //需要知道要交互的同事类--CPU类
    private CPU cpu = null;
    //需要知道要交互的同事类--显卡类
    private VideoCard videoCard = null;
    //需要知道要交互的同事类--声卡类
    private SoundCard soundCard = null;
    
    @Override
    public void changed(Colleague colleague) {
        if(colleague == cdDriver){
            //表示光驱读取数据了
            this.openCDDriverReadData((CDDriver)colleague);
        }else if(colleague == cpu){
            //表示CPU处理完了
            this.openCPU((CPU)colleague);
        }
    }

    private void openCDDriverReadData(CDDriver cdDriver){
        //1. 先获取光驱读取的数据
        String data = cdDriver.getData();
        //2. 把这些数据传递给CPU进行处理
        this.cpu.executeData(data);
    }
    
    /**
     * 处理CPU处理完数据后与其他对象的交互
     */
    private void openCPU(CPU cpu){
        //1. 先获取CPU处理后的数据
        String videoData = cpu.getVideoData();
        String soundData = cpu.getSoundData();
        //2. 把这些数据传递给显卡和声卡
        this.videoCard.showData(videoData);
        this.soundCard.soundData(soundData);
    }
    
    public void setCdDriver(CDDriver cdDriver) {
        this.cdDriver = cdDriver;
    }

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

    public void setVideoCard(VideoCard videoCard) {
        this.videoCard = videoCard;
    }

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

/*
测试类
*/
public class Client {
    public static void main(String[] args) {
        //1.创建中介者---主板对象
        MediatorBoard mediator = new MediatorBoard();
        
        //创建同事类
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        VideoCard vc = new VideoCard(mediator);
        SoundCard sc = new SoundCard(mediator);
        
        //让中介者知道所有的同事
        mediator.setCdDriver(cd);
        mediator.setCpu(cpu);
        mediator.setVideoCard(vc);
        mediator.setSoundCard(sc);
        
        //开始看电影
        cd.readCD();
    }
}

3、模式讲解                                                           

3.1中介者模式的功能

　　中介者模式的功能非常简单，就是封装对象之间的交互。把所有对象之间的交互封装在中介者当中，无形中还可以得到另外一个好处，就是能够集中地控制这些对象的交互关系，这样当有变化的时候，修改起来就很方便。

3.2 需要Mediator接口吗?

　　首先要明白接口是用来实现"封装隔离的"，那么封装谁？隔离谁呢? Mediator接口就是用来封装中介者对象的，使得使用中介者对象的同事对象跟具体的中介者实现分离开。那么有没有使用Mediator接口的必要，那就取决于是否会提供多个不同的中介者实现，如果中介者实现只有一个的话，而且预计中也没有需要扩展的要求，那么就可以不定义Mediator接口，让各个同事类直接使用中介者实现对象。

3.3 中介者模式的调用顺序示意图

4、广义中介者                                                         

查看上面标准的中介者模式的结构、定义和示例后，会发现几个问题，使得中介者模式在实际使用的时候，变得繁琐和困难：

问题一：是否有必要要同事对象定义一个公共的父类？

　　Java是单继承的，如果为了使用中介者模式，就让这些同事对象继承了一个父类，这是很不好的。

问题二：同事类有必要持有中介者对象吗?

　　同事类需要知道中介者对象，以便当它们发生改变的时候能够通知中介者对象。但是是否需要作为属性并通过构造方法传入这么强的依赖关系呢？

问题三：是否需要中介者接口？

　　在实际开发中，很常见的情况是不需要中介者接口的，中介者通常实现成单列。

问题四：中介者对象是否需要持有所有的同事？

问题五：中介者对象只是提供一个公共的方法来接受同事对象的通知吗？

　　在示例的公共方法里，需要去区分到底是谁调的。在实际开发中，通常会提供具体的业务通知方法，这样就不用再去判断到底是什么对象，具体是什么业务了.

基于上面的考虑，在实际应用开发中，经常会简化中介者模式，来使开发变得简单，比如有如下的简化：

　　1.通常会去掉同事对象的父类，这样就可以让任意的对象，只要需要相互交互，就可以成为同事。

　　2.通常不定义Mediator接口，把具体的中介者对象实现成为单列

　　3.同事对象不再持久中介者，而是在需要的时候直接获取中介者对象并调用

　　4.中介者也不再持有同事对象，而是在具体处理方法里面去创建，或者获取，或者从参数传入需要的同事对象

经过上面4个步骤的简化、变形使用的情况称为广义中介者。

5、思考中介者模式                                                     

5.1 中介者模式的优缺点

　　优点：

　　　　1.松散耦合。 中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互不依赖。

　　　　2.集中控制交互。 多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了。

　　　　3.多对多变成一对多。没有使用中介者模式的时候，同事对象之间的关系通常是多对多的，引入中介者对象以后，中介者对象和同事对象的关系通常就变成了双向的一对多。

　　缺点:　　

　　　　中介者模式的一个潜在缺点：过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到中介者的时候，会导致中介者对象变得十分复杂，而且难于管理和维护。

5.2 中介者模式的本质

　　中介者模式的本质：封装交互。 

5.3 何时选用中介者模式

　　1. 如果一组对象之间的通信方式比较复杂，导致相互依赖、结构混乱，可以采用中介者模式，把这些对象相互的交互管理起来，各个对象都只需要和中介者交互，从而使得各个对象松散耦合，结构也更清晰易懂。

　　2. 如果一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象，可以采用中介者模式，把这个对象跟其他对象的交互封装到中介者对象里面，这个对象只需要和中介者对象交互就可以了。

 ----------------------------------------------------

参考：

　　《研磨设计模式》