中介者模式（Mediator）

一．中介者模式介绍

中介者模式（Mediator Pattern）也称为调节者模式或者调停者模式，Mediator本身就有调停者和调节者的意思。

 

 

二．中介者模式的定义

1.中介模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用,从而使他们可以松散耦合.

2.当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用,保证这些作用可以彼此独立。

3.中介者模式将多对多的相互作用转化为一对多的相互作用,中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理

 

 

三．中介者模式的UML类图

//Mediator.java(中介者)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public abstract class Mediator {
protected ConcreteColleagueA colleagueA;//具体同事类A
protected ConcreteColleagueB colleagueB;//具体同事类B

/**
* 抽象中介方法，子类实现
* */
public abstract void method();

public void setColleagueA(ConcreteColleagueA colleagueA) {
this.colleagueA = colleagueA;
}

public void setColleagueB(ConcreteColleagueB colleagueB) {
this.colleagueB = colleagueB;
}
}

//Colleague.java(也就是相互作用的对象)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public abstract class Colleague {
protected Mediator mediator;//中介者对象
public Colleague(Mediator mediator){
this.mediator = mediator;
}
/**
* 同事角色的具体行为，由子类去实现
* */
public abstract void action();
}

//ConcreteMediator.java（具体中介者角色）

/**
* Created by Administrator on 2016/5/18 0018.
*/

public class ConcreteMediator extends Mediator {
@Override
public void method() {
colleagueA.action();
colleagueB.action();
}
}

//ConcreteColleagueA.java(具体相互作用的对象)

/**
* Created by Administrator on 2016/5/18 0018.
* 具体同事A
*/

public class ConcreteColleagueA extends Colleague {
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}

@Override
public void action() {
System.out.println("ColleagueA 将信息递交给中介者处理");
}
}

//ConcreteColleagueB.java(具体相互作用的对象)

/**
* Created by Administrator on 2016/5/18 0018.
* 具体同事B
*/

public class ConcreteColleagueB extends Colleague {
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}

@Override
public void action() {
System.out.println("ColleagueB 将信息递交给中介者处理");
}
}

角色介绍

Mediator:抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。

ConcreteMediator:具体中介者角色，继承与抽象中介者，实现了父类定义的方法，他从具体的同事对象接收消息，向具体同事对象发出命令

Colleague:抽象同事类角色，定义了中介者对象的接口，他只知道中介者而不知道其他的同事对象

ConcreteColleagueA/B：具体同事类角色，继承于抽象同事类，每个具体同事类都知道本身在小范围内的行为，而不知道他在大范围内的目的

 

 

四．中介者模式的简单实现

插入CD之后，电脑主板工作，然后跟CPU，显卡，喇叭等等的相互作用的关系

 //Mediator.java(抽象的中介者)

/**
* Created by Administrator on 2016/5/18 0018.
* 抽象中介者
*/

public abstract class Mediator {
/**
* 同事对象改变时通知中介者的方法
* 在同事对象改变时由中介者去通知其他的同事对象
* @param  C同事对象
* */
public abstract void changed(Colleague c);

}

//MainBoard.java (具体中介者，处理CPU,显卡，扬声器等之间的关系)

/**
* Created by Administrator on 2016/5/18 0018.
* 主板中介者
*/

public class MainBoard extends Mediator {
private CDDevice cdDevice;//光驱设备
private CPU cpu;//CPU
private SoundCard soundCard;//声卡设备
private GraphicsCard graphicsCard;//显卡设备
@Override
public void changed(Colleague c) {
//如果是光驱读取到了数据
if(c == cdDevice){
handleCD((CDDevice)c);
}
//如果CPU处理完数据
else if(c == cpu){
handleCPU((CPU)c);
}
}

/**
* 处理光驱读取数据后与其他设备的交互
*@param cdDevice 光驱设备
* */
private void handleCD(CDDevice cdDevice){
cpu.decodeData(cdDevice.read());
}

/**
* 处理CPU读取数据后与其他设备的交互
* @param cpu cpu
* */
private void handleCPU(CPU cpu){
soundCard.soundPlay(cpu.getDataSound());
graphicsCard.videoPlay(cpu.getDataVideo());
}

/**
* 设置cd设备
* @param  cdDevice CD设备
* */
public void setCDDevice(CDDevice cdDevice){
this.cdDevice = cdDevice;
}

/**
* 设置CPU
* @param  cpu CPU
* */
public void setCPU(CPU cpu){
this.cpu = cpu;
}

/**
* 设置声卡设备
* @param soundCard 声卡设备
* */
public void setSoundCard(SoundCard soundCard){
this.soundCard = soundCard;
}

/**
* 设置显卡设备
* @param graphicsCard 显卡设备
* */
public  void setGraphicsCard(GraphicsCard graphicsCard){
this.graphicsCard = graphicsCard;
}
}

//Colleague.java(抽象的相互作用的对象)

/**
* Created by Administrator on 2016/5/18 0018.
* 抽象同事
*/

public abstract class Colleague {
protected  Mediator mediator;//每一个同事都该知道其中介者

public Colleague(Mediator mediator) {
this.mediator = mediator;
}
}

//CDDevice.java(相互作用的对象之一 CD)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public class CDDevice extends Colleague {
private String data;//视频数据

public CDDevice(Mediator mediator) {
super(mediator);
}

public String read(){
return data;
}

public void load(){
//实际情况中视频数据与音频数据都在一个数据流中
data = "视频数据，音频数据";
//通知中介者，也就是主板数据改变
mediator.changed(this);
}
}

//GraphicsCard.java(相互作用的对象之一 显卡)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public class GraphicsCard extends Colleague {

public GraphicsCard(Mediator mediator) {
super(mediator);
}

public void videoPlay(String data){
System.out.println("视频："+data);
}
}

//SoundCard.java(相互作用的对象之一 声卡)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public class SoundCard extends Colleague {
public SoundCard(Mediator mediator) {
super(mediator);
}

public void soundPlay(String data){
System.out.println("音频："+data);
}
}

//CPU.java(相互作用的对象之一 CPU)

/**
* Created by Administrator on 2016/5/18 0018.
*/

public class CPU extends Colleague {
private  String dataVideo ,dataSound;//视频和音频数据

public CPU(Mediator mediator) {
super(mediator);
}

public String getDataVideo(){
return  dataVideo;
}

public String getDataSound(){
return dataSound;
}

public void decodeData(String data){
//分割音,视频数据
String[] tmp = data.split(",");
//解析音,视频数据
dataVideo = tmp[0];
dataSound = tmp[1];
//告诉中介者自身状态改变
mediator.changed(this);
}
}

//Mainactvity.java

public class MainActivity extends Activity{

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

//构造主板对象
MainBoard mediator = new MainBoard();
//分别构造各个零部件
CDDevice cd = new CDDevice(mediator);
CPU cpu = new CPU(mediator);
GraphicsCard vc = new GraphicsCard(mediator);
SoundCard sc = new SoundCard(mediator);

//将各个零部件安装到主板
mediator.setCDDevice(cd);
mediator.setCPU(cpu);
mediator.setGraphicsCard(vc);
mediator.setSoundCard(sc);

//完成后就可以开始放片了
cd.load();
}
}

输出结果如下：

音频：音频数据

视频：视频数据

中介者模式就是用来协调多个对象之间的交互的，就像上面示例中的主板，如果没有主板这个中介者，那么电脑里的每一个零部件都要与其他零部件建立关联，比如CPU要与内存交互,CPU要与显卡交互，CPU还要与IO设备交互等，这么一来就会构成一个错综复杂的网状图，而中介者模式的出现则是将这一个错综复杂的网状图变成一个结构清晰的星型图，其中心就是中介者

 

5.Android源码中的中介者模式实现

待添加？？？？

 

6.中介者模式实践

比如有几个EditText,checkbox,状态可以互相影响，这样就可以他们变化的监听器中都调用change(),然后在change中根据不同组件的状态进行改变

Activity充当中介者来协调这些控件的状态

 

7.总结：

在面向对象的编程语言里，一个类必然会与其他类产生依赖关系，如果这种依赖关系如网状般错综复杂，那么必然影响我们的代码逻辑以及执行效率，适当地使用中介者模式可以对这种依赖关系进行解耦使逻辑结构清晰。    当然后如果几个类间的依赖关系并不复杂，使用中介者模式反而会使得原本不复杂的逻辑结构变得复杂。