9 行为型模式之 - 中介者模式

Posted 2020-09-12 书读百遍，其义自现

中介者模式的介绍：中介者模式是行为型模式这一，在日常生活中，比如两口子吵架，孩子和双方的父母会劝架，孩子和双方的父母就称有中介者的意思，就是“和事佬”，也就是说调解两个起争端的人。而中介绍者模式比这个例子要复杂的多，上面的例子只是涉及到2个人的，中介者模式要涉及的对象是多个。多个对象之间的交互关系，是很复杂的，是网状的关系，中介者就是要把这种多对多的关系转化为一对多的关系，就是转化为星状结构，如下图

 

网状关系

 

星状关系

 

 

中介模式的定义：中介者模式包装了一系列对象的相互交互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合，当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用，保证这些作用可以彼此独立的变化，中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

中介者模式的使用场景：当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其它对象的行为，可采用中介者模式，来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状系统变成以中介者为中心的星状形结构，达到降低系统的复杂性，提高可扩展性的作用。

 

中介者模式简单的实现，比如我们每天都在使用的电脑就是一个中介者的例子，以电脑主机为例，我们都知道电脑主机分为主要的几块：CPU，内存，显卡，IO设备等我们需要一样东西将这些零件都整合起来变成一个完整的整体，这个东西就是主板，在这里主板就起到了中介者的使用，连接CPU，内存，显示和IO设备等，任何两个模式之间的通信都会经过主板去协调，这里以读取光盘为例，来看看主板是如何充当一个中介者角色的。首先定义一个抽象的中介者。

1 /**
2  * 抽象中介者
3  */
4 public abstract class Mediator {
5     public abstract void changed(Colleague c);
6 }

抽象中介者只是定义了一个抽象的接口方法，具体的同事类通过该方法来通知中介者自身的状态改变。而具体的中介者这里就是主板，由它负责联系各个具体同事类，也就是CPU，内存，显卡，IO设备等

 1 /**
 2  * 具体的中介者，也就是主板
 3  */
 4 public class MainBoard extends Mediator{
 5     private CDDevice cdDevice;
 6     private CPU cpu;
 7     private SoundCard soundCard;
 8     private GraphicsCard graphicsCard;
 9 
10     public void setCdDevice(CDDevice cdDevice) {
11         this.cdDevice = cdDevice;
12     }
13 
14     public void setCpu(CPU cpu) {
15         this.cpu = cpu;
16     }
17 
18     public void setSoundCard(SoundCard soundCard) {
19         this.soundCard = soundCard;
20     }
21 
22     public void setGraphicsCard(GraphicsCard graphicsCard) {
23         this.graphicsCard = graphicsCard;
24     }
25 
26     public void changed(Colleague c){
27         if(c == cdDevice){
28             handleCD((CDDevice) c);
29         }else if(c == cpu){
30             handleCPU((CPU) c);
31         }
32 
33     }
34 
35     //处理光驱读取数据后与其他设备的交互
36     private void handleCD(CDDevice cdDevice){
37         cpu.decodeData(cdDevice.read());
38     }
39 
40     //处理CPU读取数据后与其它设备的交互
41     private void handleCPU(CPU cpu){
42         soundCard.soundPlay(cpu.getDataSound());
43         graphicsCard.videoPlay(cpu.getDataVideo());
44     }
45 }

 

抽象同事类里只有一个抽象中介者的引用，我们在构造方法中为其赋值

 1 /**
 2  *
 3  * 同事类（也就是多个交互对象的基类）
 4  */
 5 public abstract class Colleague {
 6     protected Mediator mediator;  //每一个同事都知道其中介者
 7 
 8 
 9     public Colleague(Mediator mediator){
10         this.mediator = mediator;
11     }
12 }

接下来就是每个具体的同事类了，在这个例子中就是CPU，内存，显卡，IO设备等。

 1 /**
 2  * CPU
 3  */
 4 public class CPU extends Colleague{
 5     private String dataVideo;
 6     private String dataSound;
 7 
 8 
 9     public CPU(Mediator mediator) {
10         super(mediator);
11     }
12 
13 
14     //获取视频数据
15     public String getDataVideo(){
16         return dataVideo;
17     }
18 
19     public String getDataSound(){
20         return dataSound;
21     }
22 
23     //解码数据
24     public void decodeData(String data){
25         String[] tmp = data.split(",");
26 
27         dataVideo = tmp[0];
28         dataSound = tmp[1];
29 
30         mediator.changed(this);
31     }
32 }

 

显卡类：

 1 /**
 2  * 显卡类
 3  */
 4 public class GraphicsCard extends Colleague {
 5 
 6     public GraphicsCard(Mediator mediator) {
 7         super(mediator);
 8     }
 9 
10     //播放视频
11     public void videoPlay(String data) {
12         System.out.println("视频：" + data);
13     }
14 
15 }

 

声卡类：

 1 /**
 2  * 声卡类
 3  */
 4 public class SoundCard extends Colleague {
 5     public SoundCard(Mediator mediator) {
 6         super(mediator);
 7     }
 8 
 9     //播放音频
10     public void soundPlay(String data) {
11         System.out.println("音频：" + data);
12     }
13 }

 

CD类：

 1 /**
 2  * CD 类
 3  */
 4 public class CDDevice extends Colleague{
 5     private String data;    //视频数据
 6 
 7     public CDDevice(Mediator mediator) {
 8         super(mediator);
 9     }
10 
11     //读取视频数据
12     public String read(){
13         return data;
14     }
15 
16     //加载视频数据
17     public void load(){
18         data = "视频数据,音频数据";
19 
20         //通知中介者，也就是主板数据改变
21         mediator.changed(this);
22     }
23 
24 
25 }

 

最后是测试类

 1 /**
 2  * 中介者模式 测试类
 3  */
 4 public class MediatorTest {
 5 
 6     public static void test(){
 7         //构造一个主板
 8         MainBoard mediator = new MainBoard();
 9 
10         //分别构造各种零件
11         CDDevice cdDevice = new CDDevice(mediator);
12         CPU cpu = new CPU(mediator);
13         GraphicsCard graphicsCard = new GraphicsCard(mediator);
14         SoundCard soundCard = new SoundCard(mediator);
15 
16         //将各个零件安装到主板
17         mediator.setCdDevice(cdDevice);
18         mediator.setCpu(cpu);
19         mediator.setSoundCard(soundCard);
20         mediator.setGraphicsCard(graphicsCard);
21 
22         //完成后可以开始播放片了
23         cdDevice.load();
24     }
25 }

 

可见，可种零件的交互不是直接交互了，都是通过主板进行交互，这里主板就充当了一个中介者的作用。中介者模式降低了对象之间关系的复杂度