在阎宏博士的《JAVA与模式》一书中开头是这样描述调停者（Mediator）模式的：
调停者模式是对象的行为模式。调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。
为什么需要调停者
如下图所示，这个示意图中有大量的对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。从图中可以看出，几乎每一个对象都需要与其他的对象发生相互作用，而这种相互作用表现为一个对象与另一个对象的直接耦合。这就是过度耦合的系统。
通过引入调停者对象(Mediator)，可以将系统的网状结构变成以中介者为中心的星形结构，如下图所示。在这个星形结构中，同事对象不再通过直接的联系与另一个对象发生相互作用；相反的，它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入造成大量的修改工作。
一个好的面向对象的设计可以使对象之间增加协作性(Collaboration)，减少耦合度(Couping)。一个深思熟虑的设计会把一个系统分解为一群相互协作的同事对象，然后给每一个同事对象以独特的责任，恰当的配置它们之间的协作关系，使它们可以在一起工作。
如果没有主板
大家都知道，电脑里面各个配件之间的交互，主要是通过主板来完成的。如果电脑里面没有了主板，那么各个配件之间就必须自行相互交互，以互相传送数据。而且由于各个配件的接口不同，相互之间交互时，还必须把数据接口进行转换才能匹配上。
所幸是有了主板，各个配件的交互完全通过主板来完成，每个配件都只需要和主板交互，而主板知道如何跟所有的配件打交道，这样就简单多了。
调停者模式的结构
调停者模式的示意性类图如下所示：
调停者模式包括以下角色：
● 抽象调停者(Mediator)角色：定义出同事对象到调停者对象的接口，其中主要方法是一个（或多个）事件方法。
● 具体调停者(ConcreteMediator)角色：实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。
● 抽象同事类(Colleague)角色：定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。
● 具体同事类(ConcreteColleague)角色：所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的调停者通信，调停者会负责与其他的同事交互。
源代码
抽象调停者类
public interface Mediator {
/**
* 同事对象在自身改变的时候来通知调停者方法
* 让调停者去负责相应的与其他同事对象的交互
*/
public void changed(Colleague c);
}
具体调停者类
public class ConcreteMediator implements Mediator {
//持有并维护同事A
private ConcreteColleagueA colleagueA;
//持有并维护同事B
private ConcreteColleagueB colleagueB;
public void setColleagueA(ConcreteColleagueA colleagueA) {
this.colleagueA = colleagueA;
}
public void setColleagueB(ConcreteColleagueB colleagueB) {
this.colleagueB = colleagueB;
}
@Override
public void changed(Colleague c) {
/**
* 某一个同事类发生了变化，通常需要与其他同事交互
* 具体协调相应的同事对象来实现协作行为
*/
}
}
抽象同事类
public abstract class Colleague {
//持有一个调停者对象
private Mediator mediator;
/**
* 构造函数
*/
public Colleague(Mediator mediator){
this.mediator = mediator;
}
/**
* 获取当前同事类对应的调停者对象
*/
public Mediator getMediator() {
return mediator;
}
}
具体同事类
public class ConcreteColleagueA extends Colleague {
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
/**
* 示意方法，执行某些操作
*/
public void operation(){
//在需要跟其他同事通信的时候，通知调停者对象
getMediator().changed(this);
}
}
public class ConcreteColleagueB extends Colleague {
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
/**
* 示意方法，执行某些操作
*/
public void operation(){
//在需要跟其他同事通信的时候，通知调停者对象
getMediator().changed(this);
}
}
使用电脑来看电影
在日常生活中，我们经常使用电脑来看电影，把这个过程描述出来，简化后假定会有如下的交互过程：
（1）首先是光驱要读取光盘上的数据，然后告诉主板，它的状态改变了。
（2）主板去得到光驱的数据，把这些数据交给CPU进行分析处理。
（3）CPU处理完后，把数据分成了视频数据和音频数据，通知主板，它处理完了。
（4）主板去得到CPU处理过后的数据，分别把数据交给显卡和声卡，去显示出视频和发出声音。
要使用调停者模式来实现示例，那就要区分出同事对象和调停者对象。很明显，主板是调停者，而光驱、声卡、CPU、显卡等配件，都是作为同事对象。
源代码
抽象同事类
public abstract class Colleague {
//持有一个调停者对象
private Mediator mediator;
/**
* 构造函数
*/
public Colleague(Mediator mediator){
this.mediator = mediator;
}
/**
* 获取当前同事类对应的调停者对象
*/
public Mediator getMediator() {
return mediator;
}
}
同事类——光驱
public class CDDriver extends Colleague{
//光驱读取出来的数据
private String data = "";
/**
* 构造函数
*/
public CDDriver(Mediator mediator) {
super(mediator);
}
/**
* 获取光盘读取出来的数据
*/
public String getData() {
return data;
}
/**
* 读取光盘
*/
public void readCD(){
//逗号前是视频显示的数据，逗号后是声音
this.data = "One Piece,海贼王我当定了";
//通知主板，自己的状态发生了改变
getMediator().changed(this);
}
}
同事类——CPU
public class CPU extends Colleague {
//分解出来的视频数据
private String videoData = "";
//分解出来的声音数据
private String soundData = "";
/**
* 构造函数
*/
public CPU(Mediator mediator) {
super(mediator);
}
/**
* 获取分解出来的视频数据
*/
public String getVideoData() {
return videoData;
}
/**
* 获取分解出来的声音数据
*/
public String getSoundData() {
return soundData;
}
/**
* 处理数据，把数据分成音频和视频的数据
*/
public void executeData(String data){
//把数据分解开，前面是视频数据，后面是音频数据
String[] array = data.split(",");
this.videoData = array[0];
this.soundData = array[1];
//通知主板，CPU完成工作
getMediator().changed(this);
}
}
同事类——显卡
public class VideoCard extends Colleague {
/**
* 构造函数
*/
public VideoCard(Mediator mediator) {
super(mediator);
}
/**
* 显示视频数据
*/
public void showData(String data){
System.out.println("您正在观看的是：" + data);
}
}
同事类——声卡
public class SoundCard extends Colleague {
/**
* 构造函数
*/
public SoundCard(Mediator mediator) {
super(mediator);
}
/**
* 按照声频数据发出声音
*/
public void soundData(String data){
System.out.println("画外音：" + data);
}
}
抽象调停者类
public interface Mediator {
/**
* 同事对象在自身改变的时候来通知调停者方法
* 让调停者去负责相应的与其他同事对象的交互
*/
public void changed(Colleague c);
}
具体调停者类
public class MainBoard implements Mediator {
//需要知道要交互的同事类——光驱类
private CDDriver cdDriver = null;
//需要知道要交互的同事类——CPU类
private CPU cpu = null;
//需要知道要交互的同事类——显卡类
private VideoCard videoCard = null;
//需要知道要交互的同事类——声卡类
private SoundCard soundCard = null;
public void setCdDriver(CDDriver cdDriver) {
this.cdDriver = cdDriver;
}
public void setCpu(CPU cpu) {
this.cpu = cpu;
}
public void setVideoCard(VideoCard videoCard) {
this.videoCard = videoCard;
}
public void setSoundCard(SoundCard soundCard) {
this.soundCard = soundCard;
}
@Override
public void changed(Colleague c) {
if(c instanceof CDDriver){
//表示光驱读取数据了
this.opeCDDriverReadData((CDDriver)c);
}else if(c instanceof CPU){
this.opeCPU((CPU)c);
}
}
/**
* 处理光驱读取数据以后与其他对象的交互
*/
private void opeCDDriverReadData(CDDriver cd){
//先获取光驱读取的数据
String data = cd.getData();
//把这些数据传递给CPU进行处理
cpu.executeData(data);
}
/**
* 处理CPU处理完数据后与其他对象的交互
*/
private void opeCPU(CPU cpu){
//先获取CPU处理后的数据
String videoData = cpu.getVideoData();
String soundData = cpu.getSoundData();
//把这些数据传递给显卡和声卡展示出来
videoCard.showData(videoData);
soundCard.soundData(soundData);
}
}
客户端类
public class Client {
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();
}
}
运行结果如下：aaarticlea/png;base64,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" alt="" />
调停者模式的优点
● 松散耦合
调停者模式通过把多个同事对象之间的交互封装到调停者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。
● 集中控制交互
多个同事对象的交互，被封装在调停者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改调停者对象就可以了，当然如果是已经做好的系统，那么就扩展调停者对象，而各个同事类不需要做修改。
● 多对多变成一对多
没有使用调停者模式的时候，同事对象之间的关系通常是多对多的，引入调停者对象以后，调停者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。
调停者模式的缺点
调停者模式的一个潜在缺点是，过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到调停者的时候，会导致调停者对象变得十分复杂，而且难于管理和维护。