基础知识(08) -- 中介者模式
思维导图
----------------------------------------------------------------------
1、场景问题
大家都知道电脑的主要配件有：CPU、内存、硬盘、显卡、声卡、网卡、光驱、主板等，这些配件它们之间都是通过主板来完成相互之间的交互工作，但是如果没有了主板会怎么样呢？
如果没有了主板情况，那么各个配件之间就需要自行相互交互，以相互传送数据，如下图：
如果有主板的情况，各个配件的交互完全通过主板来完成，每个配件都只需要和主板交互，而主板知道如何和所有的配件交互，如下图：
如果上面的情况发生在软件开发中呢？ 就相当于出现了多个类之间相互交互，而且交互的很频繁，导致每个类都必须知道所有需要交互的类，也就是我们常说的类和类耦合了，是不是很麻烦？那该如何来简化这种多个对象之间的交互呢？ ----> 使用中介者模式来解决。
演示案例：程序模拟用电脑来看电影，简化后的流程如下：
第一步：首先是光驱要读取光盘上的数据，然后告诉主板，它的状态改变了
第二步：主板去得到光驱的数据，把这些数据交给CPU进行分析处理
第三步：CPU处理完后，把数据分成了视频数据和音频数据，通知主板，它处理完了
第四步：主板去得到CPU处理过后的数据，分别把数据交给显卡和声卡，去显示出视频和发出声音
上面的流程是持续的、不断重复的直到电影播放完毕，下面使用程序把这个过程实现出来：
2、解决方案 --- 使用中介者模式来解决问题
2.1 中介者模式的定义：
用一个中介对象来封装一系列的对象交互。中介者使得各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
2.2 使用中介者模式来解决问题的思路：
通过分析上面的问题，根本原因就在于多个对象需要相互交互，从而导致对象之间紧密耦合，不利于对象的修改和维护。
使用中介者模式解决问题的思路很简单，中介者模式通过引入一个中介者对象，让其他的对象都只和中介对象交互，而中介对象知道如何和其他所有的对象交互，这样对象之间的依赖关系就没有了，从而实现了对象之间的解耦。（对于中介对象而言，所有相互交互的对象，被视为同事类；中介对象就是来维护各个同事之间的关系，而所有的同事类都只是和中介对象交互。）
2.3 中介者模式的结构和说明：
说明：
Mediator: 中介者接口。在里面定义各个同事之间交互需要的方法。
ConcreteMediator： 具体中介者实现对象。它需要了解并维护各个同事对象，并肩负具体的协调各同事对象的交互关系。
Colleague: 同事类的定义，通常实现成为抽象方法，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能。
ConcreteColleague: 具体的同事类，实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同事交互。
中介者模式的示例代码：
1 /** 2 * 同事类的抽象父类 5 */ 6 public abstract class Colleague { 7 8 //持有中介者对象,每一个同事类都知道它的中介者对象 9 private Mediator mediator; 10 11 /** 12 * 构造方法,传入中介者对象 13 * @param mediator 14 */ 15 public Colleague(Mediator mediator) { 16 this.mediator = mediator; 17 } 18 19 /** 20 * 获取当前同事类对应的中介者对象 21 * @return 22 */ 23 public Mediator getMediator() { 24 return mediator; 25 } 26 } 27 28 /** 29 * 具体的同事类A 30 */ 31 public class ConcreteColleagueA extends Colleague { 32 33 public ConcreteColleagueA(Mediator mediator) { 34 super(mediator); 35 } 36 37 /** 38 * 示意方法，执行某些业务功能 39 */ 40 public void someOperation(){ 41 //在需要跟其他同事通信的时候，通知中介者对象 42 getMediator().change(this); 43 } 44 } 45 46 /** 47 * 具体的同事类B 48 */ 49 public class ConcreteColleagueB extends Colleague { 50 51 public ConcreteColleagueB(Mediator mediator) { 52 super(mediator); 53 } 54 55 /** 56 * 示意方法，执行某些业务功能 57 */ 58 public void someOperation(){ 59 //在需要跟其他同事通信的时候，通知中介者对象 60 getMediator().change(this); 61 } 62 } 63 64 65 /** 66 * 中介者，定义各个同事对象通信的接口 67 */ 68 public interface Mediator { 69 /** 70 * 同事对象在自身改变的时候来通知中介者的方法 71 * 让中介者去负责相应的与其他同事对象的交互 72 * @param colleague 同事对象自身 73 */ 74 public void change(Colleague colleague); 75 } 76 77 /** 78 * 具体的中介者实现 81 */ 82 public class ConcreteMediator implements Mediator { 83 84 //持有并维护同事A 85 private ConcreteColleagueA colleagueA; 86 87 //持有并维护同事B 88 private ConcreteColleagueB colleagueB; 89 90 public ConcreteMediator() { 91 } 92 93 @Override 94 public void change(Colleague colleague) { 95 //某个同事类发生了变化，通常需要与其他同事交互 96 //具体协调相应的同事对象来实现协作行为 97 } 98 99 /** 100 * 设置中介者需要了解并维护的同事A对象 101 * @param colleagueA 同事A对象 102 */ 103 public void setColleagueA(ConcreteColleagueA colleagueA) { 104 this.colleagueA = colleagueA; 105 } 106 107 /** 108 * 设置中介者需要了解并维护的同事B对象 109 * @param colleagueB 同事B对象 110 */ 111 public void setColleagueB(ConcreteColleagueB colleagueB) { 112 this.colleagueB = colleagueB; 113 } 114 }
使用中介模式来描述电脑看电影的流程：
1 /** 2 * 所有同事的抽象父类 3 */ 4 public abstract class Colleague { 5 private Mediator mediator; 6 7 public Colleague(Mediator mediator){ 8 this.mediator = mediator; 9 } 10 11 public Mediator getMediator() { 12 return mediator; 13 } 14 } 15 16 /** 17 * 同事类： 光驱类 18 */ 19 public class CDDriver extends Colleague { 20 //光驱读取出来的数据 21 private String data = ""; 22 23 public CDDriver(Mediator mediator) { 24 super(mediator); 25 } 26 27 /** 28 * 读取光盘 29 */ 30 public void readCD(){ 31 this.data = "学习研磨设计模式,中介者模式"; 32 //通知主板，自己的状态发生了改变 33 this.getMediator().changed(this); 34 } 35 36 public String getData() { 37 return data; 38 } 39 } 40 41 /** 42 * 同事类： CPU 43 */ 44 public class CPU extends Colleague{ 45 //分析出来的视频数据 46 private String videoData = ""; 47 //分析出来的音频数据 48 private String soundData = ""; 49 50 public CPU(Mediator mediator) { 51 super(mediator); 52 } 53 54 /** 55 * 处理数据，把数据 分成音频和视频的数据 56 * @param data 57 */ 58 public void executeData(String data){ 59 //把数据分解开，前面的是视频数据，后面的是音频数据 60 String[] ss = data.split(","); 61 this.videoData = ss[0]; 62 this.soundData = ss[1]; 63 64 //通知主板，CPU的工作完成了 65 this.getMediator().changed(this); 66 } 67 68 public String getVideoData() { 69 return videoData; 70 } 71 72 public String getSoundData() { 73 return soundData; 74 } 75 } 76 77 /** 78 * 同事类 ： 显卡类 79 */ 80 public class VideoCard extends Colleague { 81 82 public VideoCard(Mediator mediator) { 83 super(mediator); 84 } 85 86 /** 87 * 显示视频数据 88 * @param data 被显示的数据 89 */ 90 public void showData(String data){ 91 System.out.println("您正观看的是 : " + data); 92 } 93 } 94 95 /** 96 * 同事类: 声卡类 97 */ 98 public class SoundCard extends Colleague { 99 100 public SoundCard(Mediator mediator) { 101 super(mediator); 102 } 103 104 /** 105 * 按照声频数据发出声音 106 */ 107 public void soundData(String data){ 108 System.out.println("画外音: " + data); 109 } 110 } 111 112 /** 113 * 中介者对象的接口 114 */ 115 public interface Mediator { 116 /** 117 * 同事对象在自身改变的时候来通知中介者的方法， 118 * 让中介者去负责相应的与其他同事对象的交互 119 * @param colleague 同事对象自身，好让中介者对象通过对象实例去获取同事对象的状态 120 */ 121 public void changed(Colleague colleague); 122 } 123 124 /** 125 * 主板类，实现中介者接口 126 */ 127 public class MediatorBoard implements Mediator { 128 129 //需要知道要交互的同事类--光驱类 130 private CDDriver cdDriver = null; 131 //需要知道要交互的同事类--CPU类 132 private CPU cpu = null; 133 //需要知道要交互的同事类--显卡类 134 private VideoCard videoCard = null; 135 //需要知道要交互的同事类--声卡类 136 private SoundCard soundCard = null; 137 138 @Override 139 public void changed(Colleague colleague) { 140 if(colleague == cdDriver){ 141 //表示光驱读取数据了 142 this.openCDDriverReadData((CDDriver)colleague); 143 }else if(colleague == cpu){ 144 //表示CPU处理完了 145 this.openCPU((CPU)colleague); 146 } 147 } 148 149 private void openCDDriverReadData(CDDriver cdDriver){ 150 //1. 先获取光驱读取的数据 151 String data = cdDriver.getData(); 152 //2. 把这些数据传递给CPU进行处理 153 this.cpu.executeData(data); 154 } 155 156 /** 157 * 处理CPU处理完数据后与其他对象的交互 158 */ 159 private void openCPU(CPU cpu){ 160 //1. 先获取CPU处理后的数据 161 String videoData = cpu.getVideoData(); 162 String soundData = cpu.getSoundData(); 163 //2. 把这些数据传递给显卡和声卡 164 this.videoCard.showData(videoData); 165 this.soundCard.soundData(soundData); 166 } 167 168 public void setCdDriver(CDDriver cdDriver) { 169 this.cdDriver = cdDriver; 170 } 171 172 public void setCpu(CPU cpu) { 173 this.cpu = cpu; 174 } 175 176 public void setVideoCard(VideoCard videoCard) { 177 this.videoCard = videoCard; 178 } 179 180 public void setSoundCard(SoundCard soundCard) { 181 this.soundCard = soundCard; 182 } 183 } 184 185 /* 186 测试类 187 */ 188 public class Client { 189 public static void main(String[] args) { 190 //1.创建中介者---主板对象 191 MediatorBoard mediator = new MediatorBoard(); 192 193 //创建同事类 194 CDDriver cd = new CDDriver(mediator); 195 CPU cpu = new CPU(mediator); 196 VideoCard vc = new VideoCard(mediator); 197 SoundCard sc = new SoundCard(mediator); 198 199 //让中介者知道所有的同事 200 mediator.setCdDriver(cd); 201 mediator.setCpu(cpu); 202 mediator.setVideoCard(vc); 203 mediator.setSoundCard(sc); 204 205 //开始看电影 206 cd.readCD(); 207 } 208 }
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. 如果一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象，可以采用中介者模式，把这个对象跟其他对象的交互封装到中介者对象里面，这个对象只需要和中介者对象交互就可以了。
----------------------------------------------------
参考：
《研磨设计模式》
