【Java设计模式】· 调停者模式（Mediator Pattern）

调停者/中介者模式：

1.当多个对象需要互相交互的时候，因为情况太混乱很容易出错，而且出错后也不容易去查复修改（因为可能一个类中调用了多个其他类的方法等..），这时候需要用到调停者模式。

2.调停者模式：简单说就是把所有需要交互的类的需求（命令）集中到一个Mediator (中介) 类中，以后所有的布置/修改命令都在这个Mediator中进行，这样会使整个项目看起来易修改，扩展性高，查找问题容易等。



Mediator （中介者/调停者）：是一个接口类

MainBoard（中介者/调停者的具体类）：在MainBoard里面必须有各各需要交互的成员变量



Colleague（同事类，这里代表电脑组件）：电脑组件的父类（非抽象），含有成员变量Mediator，声明一个Colleague时必须赋予它一个Mediator



CDDriver，CPU，SoundCard，VideoCard（同事类的具体类，这里是各种电脑部件）：具体的电脑组件类，声明一个这样的类时必须赋予它一个Mediator

3.例子：如一台电脑需要播放影片，涉及到的部件有：CPU , CDDriver , SoundCard , VideoCard等，这4类部件在工作过程中需要重复互相交互，所以在电脑中又存在一个MainBoard（主板）作为它们的中介者，下面看下具体实现。

创建PcComponents作为电脑中各各部件的父类，CPU等都必须继承它

package pers.reus.model.colleague;

import pers.reus.model.mediator.Mediator;

//Colleague同事类，这里称作电脑组件类
public class PcComponents {
//声明中介者
Mediator mediator;

//声明类时必须赋予它一个中介者
public PcComponents(Mediator mediator){
this.mediator = mediator;
}

//获得中介者
public Mediator getMediator(){
return this.mediator;
}
}

中介者/调停者类

package pers.reus.model.mediator;

import pers.reus.model.colleague.PcComponents;

//中介者类
public interface Mediator {
//changed()的作用很明显，当其他硬件做出改变是，通过changed()通知中介者
public void changed(PcComponents p);
}

具体的电脑组件类，创建一个CD驱动类，播放CD就是从这个类开始

package pers.reus.model.concreteColleague;

import pers.reus.model.colleague.PcComponents;
import pers.reus.model.mediator.Mediator;

public class CDDriver extends PcComponents{
//data是播放的内容
private String data = null;

//给CD驱动类设定一个中介者
public CDDriver(Mediator mediator) {
super(mediator);
}

public String getData(){
return data;
}

//readCD(),开始播放CD
public void readCD(){
//为了方便,不给函数传参，data事先定义好
this.data = "One Piece,海贼王我当定了";

//定义好之后,通知主板（中介者）
getMediator().changed(this);
}
}

具体的电脑组件类，CPU作用是接收CD驱动带来的数据，并处理好后，分给声卡类和影像类去执行

package pers.reus.model.concreteColleague;

import pers.reus.model.colleague.PcComponents;
import pers.reus.model.mediator.Mediator;

public class CPU extends PcComponents{
//CPU包含影像data和声音data
private String videoData = null;
private String soundData = null;

//给CPU设定一个中介者
public CPU(Mediator mediator) {
super(mediator);
}

public String getVideoData() {
return videoData;
}

public String getSoundData() {
return soundData;
}

//CPU处理数据
public void executeData(String data){
//将一段String以,为标志分开两段
String[] array = data.split(",");
//第一段是影片名称
this.videoData = array[0];
//第二段是声音的数据
this.soundData = array[1];
//通知主板（中介者），CPU完成工作
getMediator().changed(this);
}

}

声卡类

package pers.reus.model.concreteColleague;

import pers.reus.model.colleague.PcComponents;
import pers.reus.model.mediator.Mediator;

public class SoundCard extends PcComponents{
//给声卡设定一个中介者
public SoundCard(Mediator mediator) {
super(mediator);
}

//放出来自CPU的数据
public void soundData(String str){
System.out.println("画外音： " + str);
}
}

影像类

package pers.reus.model.concreteColleague;

import pers.reus.model.colleague.PcComponents;
import pers.reus.model.mediator.Mediator;

public class VideoCard extends PcComponents{
//给影像设定一个中介者
public VideoCard(Mediator mediator) {
super(mediator);

}

//放出来自CPU的数据
public void showData(String str){
System.out.println("影片名称  " + str);
}
}

接下来看中介者——主板： MainBoard的代码展示了从CD驱动开始一直到4个部件全部交互完成的过程，分别是

1.打开CDDriver，CDDriver通知MainBoard完成打开工作



2.MainBoard获取CDDriver数据传给CPU

3.CPU将数据分成2段，CPU通知MainBoard完成分段工作

4.MainBoard获取CPU中被分成2段的数据，传给SoundCard和VideoCard

5.SoundCard 和 VideoCard分别播放

package pers.reus.model.concreteMediator;

import pers.reus.model.colleague.PcComponents;
import pers.reus.model.concreteColleague.CDDriver;
import pers.reus.model.concreteColleague.CPU;
import pers.reus.model.concreteColleague.SoundCard;
import pers.reus.model.concreteColleague.VideoCard;
import pers.reus.model.mediator.Mediator;

public class MainBoard implements Mediator{
//主板必须知道4个需要交互的成员
private CDDriver cdDriver;
private CPU cpu;
private SoundCard soundCard;
private VideoCard videoCard;

/* *
* 因为4个成员也知道主板，
* 也会调用转的changed函数，
* 所以changed函数里还有判断是哪个成员调用了这个函数
* */
public void changed(PcComponents c) {
//判断是否为CD驱动
if (c instanceof CDDriver) {
// 表示CD驱动读取数据了
this.openCDDriverReadData((CDDriver) c);
}//判断是否为CPU
else if (c instanceof CPU) {
// 表示CPU驱动读取数据了
this.openCPU((CPU) c);
}
}
/* *
* CD驱动的特定函数,
* 从CDDriver类知道,
* 在CDDriver通知MainBoard之前,
* 已经先set好了一段data,现在要处理这段data
*  */
public void openCDDriverReadData(CDDriver c){
setCdDriver(c);
String data = cdDriver.getData();
//将来自CDDriver的data交给CPU处理
cpu.executeData(data);
}

//CPU告知MainBoard完成工作后，会调用这个函数
public void openCPU(CPU c){
setCpu(c);
//先获取CPU处理后的数据
String videoData = cpu.getVideoData();
String soundData = cpu.getSoundData();
//把这些数据传递给显卡和声卡展示出来
videoCard.showData(videoData);
soundCard.soundData(soundData);
}

public void setCdDriver(CDDriver cdDriver) {
this.cdDriver = cdDriver;
}

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

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

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

}

最后是测试： 调停者模式比较重要一点是，要调停者（中介者）和 被调停者都互相知道对方的存在，所以声明的时候需要如下

package pers.reus.model.client;

import pers.reus.model.concreteColleague.CDDriver;
import pers.reus.model.concreteColleague.CPU;
import pers.reus.model.concreteColleague.SoundCard;
import pers.reus.model.concreteColleague.VideoCard;
import pers.reus.model.concreteMediator.MainBoard;

public class MediatorPatternClient {

public static void main(String[] args) {
//创建调停者——主板
MainBoard mediator = new MainBoard();
//创建同事类,这里是电脑部件
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();

}

}

结果：

影片名称：  One Piece
画外音:  海贼王我当定了

这就是将多个需要交互的类的请求集中在一个中介类里面完成的——调停者模式，它的好处的让工作的过程更加清晰地被人了解，不易出错。

ps:这个模式自己学了比较久，其实重点就是上面那句话：将多个需要交互的类的请求集中在一个中介类里面完成。 而代码完完全全是在网上找到，自己也理解很很久，而里面的注释大部分是自己加上去，这样便于大家理解。如果发现错误或者疑惑，欢迎邀请我一起讨论，一起进步。