“和事佬”-中介者模式（调节者模式/调停者模式）
定义
中介者模式包装了一系列对象相互作用的方式，使得这些对象相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化，中介者模式将多对多的相互作用转化为一对多的相互作用。中介者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。
使用场景
当对象之间的交互操作很多且每个对象的行为对象都依赖彼此时，为防止在修改一个对象的行为时，同时涉及很多其他对象的行为，可采用中介者模式，来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者模式将系统从网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可拓展性的作用
简单实现
抽象中介者
1
2
3
4
5
|
package MediatorPattern;
public abstract class Mediator {
public abstract void changed(Colleague c);
}
|
主板中介者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
package MediatorPattern;
public class MainBoard extends Mediator {
private CDDevice cdDevice;
private CPU cpu;
private SoundCard soundCard;
private GraphicsCard graphicsCard;
public void changed(Colleague c) {
if(c==cdDevice){
handleCD((CDDevice)c);
}else if(c==cpu){
handleCPU((CPU)c);
}
}
private void handleCD(CDDevice cdDevice){
cpu.decodeData(cdDevice.read());
}
private void handleCPU(CPU cpu){
soundCard.soundPlay(cpu.getDataSound());
graphicsCard.videoPlay(cpu.getDataVideo());
}
public void setCdDevice(CDDevice cdDevice) {
this.cdDevice = cdDevice;
}
public void setCpu(CPU cpu) {
this.cpu = cpu;
}
public void setSoundCard(SoundCard soundCard) {
this.soundCard = soundCard;
}
public void setGraphicsCard(GraphicsCard graphicsCard) {
this.graphicsCard = graphicsCard;
}
}
|
抽象同事
1
2
3
4
5
6
7
8
9
10
|
package MediatorPattern;
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator){
this.mediator=mediator;
}
}
|
CPU同事
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package MediatorPattern;
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);
}
}
|
光驱同事
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package MediatorPattern;
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);
}
}
|
显卡同事
1
2
3
4
5
6
7
8
9
10
11
|
package MediatorPattern;
public class GraphicsCard extends Colleague {
public GraphicsCard(Mediator mediator) {
super(mediator);
}
public void videoPlay(String data){
System.out.println("视频:"+data);
}
}
|
声卡同事
1
2
3
4
5
6
7
8
9
10
11
|
package MediatorPattern;
public class SoundCard extends Colleague {
public SoundCard(Mediator mediator) {
super(mediator);
}
public void soundPlay(String data){
System.out.println("音频:"+data);
}
}
|
执行结果
小结
在面向对象的编程语言里，一个类必然会与其他类产生依赖关系，如果这种关系如网状般错综复杂，那么必然会影响我们的代码逻辑以及执行效率，适当的使用中介者模式可以对这种依赖关系进行解耦使逻辑结构清晰，但是，如果几个类间的依赖关系并不复杂，使用中介者模式反而会使得原本不复杂的逻辑结构变的复杂，所以，我们在决定使用中介者模式的之前要多方考虑，权衡利弊。