本文参考自：《JAVA设计模式》之中介者模式(Mediator)
1. 作用
中介者模式也称为调停者模式，调停者模式是对象的行为模式。调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。
2. 需要中介者模式的原因
如下图所示，这个示意图中有大量的对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。从图中可以看出，几乎每一个对象都需要与其他的对象发生相互作用，而这种相互作用表现为一个对象与另一个对象的直接耦合。这就是过度耦合的系统。
未引入中介者模式的系统
通过引入调停者对象(Mediator)，可以将系统的网状结构变成以中介者为中心的星形结构，如下图所示。在这个星形结构中，同事对象不再通过直接的联系与另一个对象发生相互作用；相反的，它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入造成大量的修改工作。
引入中介者模式的系统
3. 结构
中介者模式结构
中介者模式的四个角色
-
抽象的中介者（Mediator）
定义出同事对象到调停者对象的接口，其中主要方法是一个（或多个）事件方法。 -
具体的中介者（ConcreteMediator）
实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。 -
抽象的同事类（Colleague）
定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。 -
具体的同事类（ConcreteColleague）
所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的调停者通信，调停者会负责与其他的同事交互。
4. 实现
抽象的中介者
public interface Mediator {
void change(Colleague c);
}
具体的中介者
public class ConcreteMediator implements Mediator{
private ConcreteColleagueA colleagueA;
private ConcreteColleagueB colleagueB;
public void setColleagueA(ConcreteColleagueA colleagueA) {
this.colleagueA = colleagueA;
}
public void setColleagueB(ConcreteColleagueB colleagueB) {
this.colleagueB = colleagueB;
}
@Override
public void change(Colleague c) {
if(c instanceof ConcreteColleagueA) {
System.out.println(((ConcreteColleagueA) c).getName());
}else if(c instanceof ConcreteColleagueB) {
System.out.println(((ConcreteColleagueB) c).getName());
}
}
}
抽象的同事类
public abstract class Colleague {
private Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public Mediator getMediator() {
return this.mediator;
}
public abstract void operate();
}
具体的同事类
public class ConcreteColleagueA extends Colleague{
private String name;
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
public String getName() {
return this.name;
}
@Override
public void operate() {
this.name = "colleagueA";
getMediator().change(this);
}
}
public class ConcreteColleagueB extends Colleague{
private String name;
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
public String getName() {
return this.name;
}
@Override
public void operate() {
this.name = "colleagueB";
getMediator().change(this);
}
}
客户端调用
public class MediatorPatternMain {
public static void main(String[] args) {
// TODO Auto-generated method stub
ConcreteMediator mediator = new ConcreteMediator();
ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
mediator.setColleagueA(colleagueA);
mediator.setColleagueB(colleagueB);
colleagueA.operate();
colleagueB.operate();
}
}
5. 具体实例
在日常生活中，我们经常使用电脑来看电影，把这个过程描述出来，简化后假定会有如下的交互过程：
（1）首先是光驱要读取光盘上的数据，然后告诉主板，它的状态改变了。
（2）主板去得到光驱的数据，把这些数据交给CPU进行分析处理。
（3）CPU处理完后，把数据分成了视频数据和音频数据，通知主板，它处理完了。
（4）主板去得到CPU处理过后的数据，分别把数据交给显卡和声卡，去显示出视频和发出声音。
要使用调停者模式来实现示例，那就要区分出同事对象和调停者对象。很明显，主板是调停者，而光驱、声卡、CPU、显卡等配件，都是作为同事对象。
框架图
抽象的中介者
public interface Mediator {
void change(Colleague colleague);
}
具体的中介者-主板类
public class MainBoard implements Mediator{
private CDReader cdReader;
private CPU cpu;
private SoundPlayer soundPlayer;
private VideoPlayer videoPlayer;
public void setCDReader(CDReader cdReader) {
this.cdReader = cdReader;
}
public void setCPU(CPU cpu) {
this.cpu = cpu;
}
public void setSoundPlayer(SoundPlayer soundPlayer) {
this.soundPlayer = soundPlayer;
}
public void setVideoPlayer(VideoPlayer videoPlayer) {
this.videoPlayer = videoPlayer;
}
@Override
public void change(Colleague colleague) {
if(colleague instanceof CDReader) {
String cdReaderData = ((CDReader)colleague).getData();
operateCPU(cdReaderData);
}else if(colleague instanceof CPU) {
List<String> cpuDataList = ((CPU)colleague).getDataList();
operateSoundPlayer(cpuDataList.get(0));
operateVideoPlayer(cpuDataList.get(1));
}
}
private void operateCPU(String data) {
cpu.operate(data);
}
private void operateSoundPlayer(String data) {
soundPlayer.playSound(data);
}
private void operateVideoPlayer(String data) {
videoPlayer.playVideo(data);
}
}
抽象的同事类
public class Colleague {
private Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public Mediator getMediator() {
return this.mediator;
}
}
具体的同事类-光驱类
public class CDReader extends Colleague{
private String data;
public CDReader(Mediator mediator) {
super(mediator);
}
public String getData() {
return this.data;
}
public void read() {
this.data = "sound,video";
getMediator().change(this);
}
}
具体的同事类-CPU类
public class CPU extends Colleague{
private List<String> dataList;
public CPU(Mediator mediator) {
super(mediator);
dataList = new ArrayList<>();
}
public List<String> getDataList(){
return dataList;
}
public void operate(String data) {
String[] liStrings = data.split(",");
dataList.add(liStrings[0]);
dataList.add(liStrings[1]);
getMediator().change(this);
}
}
具体的同事类-声卡类
public class SoundPlayer extends Colleague{
public SoundPlayer(Mediator mediator) {
super(mediator);
}
public void playSound(String sound) {
System.out.println(sound);
}
}
具体的同事类-显卡类
public class VideoPlayer extends Colleague{
public VideoPlayer(Mediator mediator) {
super(mediator);
}
public void playVideo(String video) {
System.out.println(video);
}
}
客户端调用
public class MediatorPatternDemoMain {
public static void main(String[] args) {
MainBoard mainBoard = new MainBoard();
CDReader cdReader = new CDReader(mainBoard);
CPU cpu = new CPU(mainBoard);
SoundPlayer soundPlayer = new SoundPlayer(mainBoard);
VideoPlayer videoPlayer = new VideoPlayer(mainBoard);
mainBoard.setCDReader(cdReader);
mainBoard.setCPU(cpu);
mainBoard.setSoundPlayer(soundPlayer);
mainBoard.setVideoPlayer(videoPlayer);
cdReader.read();
}
}
6. 中介者模式的优缺点
优点
-
松散耦合
调停者模式通过把多个同事对象之间的交互封装到调停者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。
-
集中控制交互
多个同事对象的交互，被封装在调停者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改调停者对象就可以了，当然如果是已经做好的系统，那么就扩展调停者对象，而各个同事类不需要做修改。 -
多对多变成一对多
没有使用调停者模式的时候，同事对象之间的关系通常是多对多的，引入调停者对象以后，调停者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。
缺点
调停者模式的一个潜在缺点是，过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到调停者的时候，会导致调停者对象变得十分复杂，而且难于管理和维护。
