JAVA设计模式-24-中介者模式

参考：http://blog.csdn.net/pengjunlee/article/details/54984322

一、什么是中介者式

中介者(Mediator)模式（亦被称为调停者模式）是一种对象的行为模式。用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
中介者模式的本质：封装交互
设计意图：

面向对象设计鼓励将行为分布到各个对象中。这种分布可能会导致多个对象之间需要相互交互，从而形成紧密耦合，不利于对象的修改和维护。在最坏的情况下,每一个对象都需要知道其他所有对象，如下图所示。

虽然将一个系统分割成许多对象通常可以增强可复用性，但是对象间相互连接的激增又会降低其可复用性。大量的相互连接使得一个对象似乎不太可能在没有其他对象的支持下工作----系统表现为一个不可分割的整体。而且，对系统的行为进行任何较大的改动都十分困难，因为行为被分布在许多对象中。结果是：你可能不得不定义很多子类以定制系统的行为。

中介者模式通过引入一个中介对象，形成了一个以中介者为中心的星形结构，如下图所示。某一个对象不再通过直接的联系与另一个对象发生相互作用，而是让所有的对象都只和中介者对象进行交互，从而实现了对象之间的解耦。中介者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入造成大量的修改工作。

二、中介者模式的结构

中介者模式涉及的角色及其职责如下：

抽象中介者(Mediator)角色：一般定义为接口，用来定义各个同事之间交互需要的方法，可以是公共的通信方法，比如 changed()方法，大家都用，也可以是小范围的交互方法。
具体中介者(ConcreteMediator)角色：实现Mediator中定义的接口，它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系。
抽象同事(Colleague)角色：通常实现成为抽象类，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是具体同事类都会持有中介者对象，都可以定义到这个类里面。

具体同事(ConcreteColleague)角色：继承自Colleague，实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者负责与他的同事交互。

中介者模式结构示意源代码如下：

先来看看所有同事的父类的定义。

[java] view plain copy

1. /** 
2.  * 同事类的抽象父类 
3.  */  
4. public abstract class Colleague {  
5.   
6.     /** 
7.      * 持有中介者对象，每一个同事类都知道它的中介者对象 
8.      */  
9.     private Mediator mediator;  
10.   
11.     public Colleague(Mediator mediator) {  
12.         this.mediator = mediator;  
13.     }  
14.   
15.     /** 
16.      * 获取当前同事类对应的中介者对象 
17.      */  
18.     public Mediator getMediator() {  
19.         return mediator;  
20.     }  
21. }  

再来看看具体的同事类，在示意中它们的实现是差不多的，示例代码如下。

[java] view plain copy

1. /** 
2.  * 具体的同事类A 
3.  */  
4. public class ConcreteColleagueA extends Colleague {  
5.   
6.     public ConcreteColleagueA(Mediator mediator) {  
7.         super(mediator);  
8.     }  
9.   
10.     public void someOperation() {  
11.         // 在需要跟其他同事通信的时候，通知中介者对象  
12.         getMediator().changed(this);  
13.     }  
14. }  

[java] view plain copy

1. /** 
2.  * 具体的同事类B 
3.  */  
4. public class ConcreteColleagueB extends Colleague {  
5.   
6.     public ConcreteColleagueB(Mediator mediator){  
7.         super(mediator);  
8.     }  
9.       
10.     public void someOperation(){  
11.         //在需要跟其他同事通信的时候，通知中介者对象  
12.         getMediator().changed(this);  
13.     }  
14. }  

接下来看看中介者接口的定义，示例代码如下。

[java] view plain copy

1. /** 
2.  * 中介者，定义各个同事对象通信的接口 
3.  */  
4. public interface Mediator {  
5.   
6.     /** 
7.      * 同事对象在自身改变的时候来通知中介者的方法，让中介者负责相应的与其他同事对象的交互 
8.      */  
9.     public void changed(Colleague colleague);  
10. }  

最后来看看具体的中介者实现，示例代码如下。

[java] view plain copy

1. /** 
2.  * 具体的中介者实现 
3.  */  
4. public class ConcreteMediator implements Mediator {  
5.   
6.     /** 
7.      * 持有并维护同事A 
8.      */  
9.     private ConcreteColleagueA colleagueA;  
10.     /** 
11.      * 持有并维护同事B 
12.      */  
13.     private ConcreteColleagueB colleagueB;  
14.   
15.     /** 
16.      * 设置中介者需要了解并维护的同事A对象 
17.      */  
18.     public void setConcreteColleagueA(ConcreteColleagueA colleagueA) {  
19.         this.colleagueA = colleagueA;  
20.     }  
21.   
22.     /** 
23.      * 设置中介者需要了解并维护的同事B对象 
24.      */  
25.     public void setConcreteColleagueB(ConcreteColleagueB colleagueB) {  
26.         this.colleagueB = colleagueB;  
27.     }  
28.   
29.     @Override  
30.     public void changed(Colleague colleague) {  
31.         // 某个同事类发生了变化，通常需要与其他同事交互  
32.         // 具体协调相应的同事对象来实现协作行为  
33.   
34.     }  
35.   
36. }  

三、中介者模式应用举例

《研磨设计模式》中给出这么一个场景：使用电脑来看电影。
在日常生活中，我们经常使用电脑来看电影，把这个过程描述出来，简化后假定会有如下的交互过程：
（1）首先是光驱要读取光盘上的数据，然后告诉主板，它的状态改变了。
（2）主板去得到光驱的数据，把这些数据交给CPU进行分析处理。
（3）CPU处理完后，把数据分成了视频数据和音频数据，通知主板，它处理完了。
（4）主板去得到CPU处理过后的数据，分别把数据交给显卡和声卡，去显示视频和播放声音。
如果使用调停者模式把这个过程描述出来，该如何具体实现呢？
要使用调停者模式来实现示例，首先要区分出同事对象和调停者对象。很明显，主板是中介者，而光驱、声卡、CPU、显卡等配件，都是作为同事对象。

根据中介者模式的知识，设计出的程序类图结构如下。

下面来看看代码实现，会更清楚。

抽象同事类的定义跟标准的实现是差不多的，示例代码如下。

[java] view plain copy

1. /** 
2.  * 抽象同事类 
3.  */  
4. public abstract class Colleague {  
5.   
6.     // 持有一个中介者对象  
7.     private Mediator mediator;  
8.   
9.     /** 
10.      * 构造函数 
11.      */  
12.     public Colleague(Mediator mediator) {  
13.         this.mediator = mediator;  
14.     }  
15.   
16.     /** 
17.      * 获取当前同事类对应的中介者对象 
18.      */  
19.     public Mediator getMediator() {  
20.         return mediator;  
21.     }  
22. }  

定义众多的同事类，示例代码如下。

[java] view plain copy

1. /** 
2.  * 光驱类，一个同事类 
3.  */  
4. public class CDDriver extends Colleague {  
5.   
6.     // 光驱读取出来的数据  
7.     private String data = "";  
8.   
9.     /** 
10.      * 构造函数 
11.      */  
12.     public CDDriver(Mediator mediator) {  
13.         super(mediator);  
14.     }  
15.   
16.     /** 
17.      * 获取光盘读取出来的数据 
18.      */  
19.     public String getData() {  
20.         return data;  
21.     }  
22.   
23.     /** 
24.      * 读取光盘 
25.      */  
26.     public void readCD(String data) {  
27.         // 逗号前是视频显示的数据，逗号后是声音  
28.         this.data = data;  
29.         // 通知主板，自己的状态发生了改变  
30.         getMediator().changed(this);  
31.     }  
32. }  

[java] view plain copy

1. /** 
2.  * CPU类，一个同事类 
3.  */  
4. public class CPU extends Colleague {  
5.   
6.     // 分解出来的视频数据  
7.     private String videoData = "";  
8.     // 分解出来的声音数据  
9.     private String audioData = "";  
10.   
11.     /** 
12.      * 构造函数 
13.      */  
14.     public CPU(Mediator mediator) {  
15.         super(mediator);  
16.     }  
17.   
18.     /** 
19.      * 获取分解出来的视频数据 
20.      */  
21.     public String getVideoData() {  
22.         return videoData;  
23.     }  
24.   
25.     /** 
26.      * 获取分解出来的声音数据 
27.      */  
28.     public String getAudioData() {  
29.         return audioData;  
30.     }  
31.   
32.     /** 
33.      * 处理数据，把数据分成视频和音频的数据 
34.      */  
35.     public void processData(String data) {  
36.         // 把数据分解开，前面是视频数据，后面是音频数据  
37.         String[] array = data.split(",");  
38.         this.videoData = array[0];  
39.         this.audioData = array[1];  
40.         // 通知主板，CPU完成工作  
41.         getMediator().changed(this);  
42.     }  
43. }  

[java] view plain copy

1. /** 
2.  * 显卡类，一个同事类 
3.  */  
4. public class VideoCard extends Colleague {  
5.       
6.     /** 
7.      * 构造函数 
8.      */  
9.     public VideoCard(Mediator mediator) {  
10.         super(mediator);  
11.     }  
12.   
13.     /** 
14.      * 显示视频数据 
15.      */  
16.     public void display(String data) {  
17.         System.out.println("您正在观看的是：" + data);  
18.     }  
19. }  

[java] view plain copy

1. /** 
2.  * 声卡类，一个同事类 
3.  */  
4. public class AudioCard extends Colleague {  
5.   
6.     /** 
7.      * 构造函数 
8.      */  
9.     public AudioCard(Mediator mediator) {  
10.         super(mediator);  
11.     }  
12.   
13.     /** 
14.      * 播放音频数据 
15.      */  
16.     public void play(String data) {  
17.         System.out.println("画外音：" + data);  
18.     }  
19. }  

接下来看看抽象中介者的定义，此处仅定义一个让同事对象在自身改变的时候来通知中介者的接口，示例代码如下。

[java] view plain copy

1. /** 
2.  * 中介者接口 
3.  */  
4. public interface Mediator {  
5.     /** 
6.      * 同事对象在自身改变的时候来通知中介者的方法 让中介者去负责相应的与其他同事对象的交互 
7.      */  
8.     public void changed(Colleague c);  
9. }  

再来看看具体中介者的实现，示例代码如下。

[java] view plain copy

1. /** 
2.  * 主板类，实现中介者接口 
3.  */  
4. public class MainBoard implements Mediator {  
5.   
6.     // 需要知道要交互的同事类——光驱类  
7.     private CDDriver cdDriver = null;  
8.     // 需要知道要交互的同事类——CPU类  
9.     private CPU cpu = null;  
10.     // 需要知道要交互的同事类——显卡类  
11.     private VideoCard videoCard = null;  
12.     // 需要知道要交互的同事类——声卡类  
13.     private AudioCard audioCard = null;  
14.   
15.     public void setCdDriver(CDDriver cdDriver) {  
16.         this.cdDriver = cdDriver;  
17.     }  
18.   
19.     public void setCpu(CPU cpu) {  
20.         this.cpu = cpu;  
21.     }  
22.   
23.     public void setVideoCard(VideoCard videoCard) {  
24.         this.videoCard = videoCard;  
25.     }  
26.   
27.     public void setAudioCard(AudioCard audioCard) {  
28.         this.audioCard = audioCard;  
29.     }  
30.   
31.     @Override  
32.     public void changed(Colleague c) {  
33.         if (c instanceof CDDriver) {  
34.             // 表示光驱已经读取数据了  
35.             this.afterCDDriverReadData((CDDriver) c);  
36.         } else if (c instanceof CPU) {  
37.             // 表示CPU已经处理数据了  
38.             this.afterCPUProcessData((CPU) c);  
39.         }  
40.     }  
41.   
42.     /** 
43.      * 光驱读取数据以后与其他对象的交互 
44.      */  
45.     private void afterCDDriverReadData(CDDriver cd) {  
46.         // 先获取光驱读取的数据  
47.         String data = cd.getData();  
48.         // 把这些数据传递给CPU进行处理  
49.         cpu.processData(data);  
50.     }  
51.   
52.     /** 
53.      * CPU处理完数据后与其他对象的交互 
54.      */  
55.   
56.     private void afterCPUProcessData(CPU cpu) {  
57.         // 先获取CPU处理后的数据  
58.         String videoData = cpu.getVideoData();  
59.         String audioData = cpu.getAudioData();  
60.         // 把这些数据传递给显卡和声卡展示出来  
61.         videoCard.display(videoData);  
62.         audioCard.play(audioData);  
63.     }  
64.   
65. }  

大功告成，在客户端中测试一下，示例代码如下。

[java] view plain copy

1. public class Client {  
2.     public static void main(String[] args) {  
3.         // 创建中介者——主板  
4.         MainBoard mediator = new MainBoard();  
5.         // 创建同事类  
6.         CDDriver cdDriver = new CDDriver(mediator);  
7.         CPU cpu = new CPU(mediator);  
8.         VideoCard videoCard = new VideoCard(mediator);  
9.         AudioCard audioCard = new AudioCard(mediator);  
10.         // 让中介者知道所有同事  
11.         mediator.setCdDriver(cdDriver);  
12.         mediator.setCpu(cpu);  
13.         mediator.setVideoCard(videoCard);  
14.         mediator.setAudioCard(audioCard);  
15.         // 开始看电影，把光盘放入光驱，光驱开始读盘  
16.         cdDriver.readCD("东京热,真的好热！");  
17.   
18.     }  
19. }  

运行程序打印结果如下：

[html] view plain copy

1. 您正在观看的是：东京热  
2. 画外音：真的好热！  

如同上例所示，对于光驱对象、CPU对象、显卡对象和声卡对象，需要相互交互，虽然只是简单演示，但是也能看出来，它们的交互是比较麻烦的，于是定义一个中介者对象----主板对象，来维护它们之间的交互关系，从而使得这些对象松散耦合。
如果这个时候需要修改它们的交互关系，直接到中介者里面修改就好了，也就是说它们的关系已经独立封装到中介者对象里面了，可以独立地改变它们之间的交互关系，而不用去修改这些同事对象。

三、广义中介者

在实际应用开发中，经常会使用简化版的中介者模式进行开发，被称为广义中介者，常有如下简化:
• 通常会去掉同事对象的父类，这样可以让任意的对象，只要需要相互交互，就可以成为同事。 
• 通常不定义Mediator接口，把具体的中介者对象实现成为单例。
• 同事对象不再持有中介者，而是在需要的时候直接获取中介者对象并调用；中介者也不再持有同事对象，而是在具体处理方法里面去创建，或者获取，或者从参数传入需要的同事对象。

四、中介者模式的优缺点

使用中介者模式的优点：

（1）松散耦合    
　中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。
（2）集中控制交互
　多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了，当然如果是已经做好的系统，那么就扩展中介者对象，而各个同事类不需要做修改。
（3）多对多变成一对多
没有使用中介者模式的时候，同事对象之间的关系通常是多对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。

使用中介者模式的缺点：

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

五、中介者模式的适用性

在以下条件下可以考虑使用中介者模式：
• 如果一组对象之间的通信方式比较复杂，导致相互依赖、结构混乱，可以采用中介者模式，把这些对象相互的交互管理起来，各个对象都只需要和中介者交互，从而使得各个对象松散耦合，结构也更清晰易懂。
• 如果一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象，可以采用中介者模式，把这个对象跟其他对象的交互封装到中介者对象里面，这个对象只需要和中介者对象交互就可以了。

六、总结

中介者模式通过引入一个中介对象，让其他的对象都只和中介对象交互，而中介对象知道如何和其他所有的对象交互，这样对象之间的交互关系就没有了，从而实现了对象之间的解耦。
对于中介对象而言，所有相互交互的对象，被视为同事类，中介对象就是来维护各个同事之间的关系，而所有的同事类都只是和中介对象交互。
每个同事对象，当自己发生变化的时候，不需要知道这会引起其他对象有什么变化，它只需要通知中介者就可以了，然后由中介者去与其他对象交互。这样松散耦合带来的好处是，除了让同事对象之间相互没有关联外，还有利于功能的修改和扩展。
有了中介者以后，所有的交互都封装到中介者对象里面，各个对象就不再需要维护这些关系了。扩展关系的时候也只需要扩展或修改中介者对象就可以了。