一、中介者模式
中介者模式又叫调解者模式或调停者模式,是行为型设计模式之一。
生活中的中介者的作用就是连接两方的一个桥梁,比如房产中介,买房的只需跟中介打交道,然后买房的也跟着中介打交道,
没有中介的时候是这样的:
image每个买房的和卖房的都要和很多对方打交道,有了新的买房人,这些卖房的都得知道才能去和他联系。
有了中介者之后:
image所有买房的和卖房的都只需要跟中介者一个人打交道,买房的不需要知道卖房的是什么人,有多少卖房的等等。都省事了很多。
定义
通过中介者包装一系列对象的交互,使得这些对象不必相互显式引用,从而使它们可以松散耦合。且可以独立地改变它们之间的交互。中介者模式又叫调停模式,它是迪米特法则的典型应用。
当某些对象之间的作用发生变化是,不会立即影响其他对象间的作用,保证这些作用协议彼此独立的变化。
中介者模式将多对多的相互作用转化为一对多的相互作用。
使用场景
多个对象之间的交互操作很多,每个对象的行为都依赖批次,形成网状的多对多结构,为了防止修改一个对象时要修改很多其他对象,可以用中介者模式。
UML
imageMediator: 抽象的中介者角色,定义了同事对象到中介者的接口。
ConcreteMediator:具体的中介者角色,从具体的同事对象接收消息,同时向具体的同事对象发出命令。
Colleague:抽象同事类角色,定义了中介者对象的接口,只知道中介而不知道其他同事对象。
ConcreteColleagueA,B:具体的同事类角色,每个具体同事类都知道本身在小范围内的行为,而不知道他在大范围中的行为。
模板代码:
抽象的中介者:
public interface Mediator {
void change();
}
具体的中介者:
public class ConcreteMediator implements Mediator {
public ConcreteColleagueA concreteColleagueA;
public ConcreteColleagueB concreteColleagueB;
public void setConcreteColleagueA(ConcreteColleagueA concreteColleagueA) {
this.concreteColleagueA = concreteColleagueA;
}
public void setConcreteColleagueB(ConcreteColleagueB concreteColleagueB) {
this.concreteColleagueB = concreteColleagueB;
}
@Override
public void change() {
concreteColleagueA.action();
concreteColleagueB.action();
}
}
抽象的同事:
public abstract class Colleague {
public Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void action();
}
具体的同事:
public class ConcreteColleagueA extends Colleague {
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
@Override
public void action() {
System.out.println("交给中介做A的事情");
}
}
public class ConcreteColleagueB extends Colleague {
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
@Override
public void action() {
System.out.println("交给中介做B的事情");
}
}
二、简单实现
以电脑为例子。CPU,显卡,内存等零件的交互都是通过主板实现的,而且每个零件只需要做好自己的工作,不需要知道其他零件是什么。所以主板可以作为他们的中介者。
抽象的中介者:
public abstract class Mediator {
public abstract void change(Colleague colleague);
}
具体的中介者,主板:
/**
* 具体的中介者:(电脑主板)
*/
public class ComputerMediator extends Mediator {
private CDDevice cdDevice;
private CPUDevice cpuDevice;
private GraphicsCard graphicsCard;
private SoundCard soundCard;
@Override
public void change(Colleague colleague) {
System.out.println("ComputerMediator: "+"change()-"+colleague);
if (colleague == cdDevice) {
handleCD((CDDevice) colleague);
}
if (colleague == cpuDevice) {
handleCPU((CPUDevice) colleague);
}
}
private void handleCD(CDDevice cdDevice) {
System.out.println("ComputerMediator: "+"handleCD()");
cpuDevice.decodeData(cdDevice.read());
}
private void handleCPU(CPUDevice cpuDevice) {
System.out.println("ComputerMediator: "+"handleCPU()");
soundCard.playSound(cpuDevice.getDataSound());
graphicsCard.vidoePlay(cpuDevice.getDataVideo());
}
public void setCdDevice(CDDevice cdDevice) {
this.cdDevice = cdDevice;
System.out.println("ComputerMediator: "+"setCdDevice()-"+cdDevice);
}
public void setCpu(CPUDevice cpuDevice) {
this.cpuDevice = cpuDevice;
System.out.println("ComputerMediator: "+"setCpu()-"+cpuDevice);
}
public void setGraphicsCard(GraphicsCard graphicsCard) {
this.graphicsCard = graphicsCard;
System.out.println("ComputerMediator: "+"setGraphicsCard()-"+graphicsCard);
}
public void setSoundCard(SoundCard soundCard) {
this.soundCard = soundCard;
System.out.println("ComputerMediator: "+"setSoundCard()-"+soundCard);
}
}
抽象的零件:
public abstract class Colleague {
public Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
}
具体的零件:
/**
* 具体的同事(零件)
*/
public class CPUDevice extends Colleague {
private String dataVideo, dataSound;
public CPUDevice(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];
System.out.println("CPUDevice: decodeData()-"+dataVideo);
System.out.println("CPUDevice: decodeData()-"+dataSound);
mediator.change(this);
}
}
public class CDDevice extends Colleague {
private String data;
public CDDevice(Mediator mediator) {
super(mediator);
}
public String read(){
return data;
}
public void load(){
data="视频数据,音频数据";
mediator.change(this);
}
}
public class GraphicsCard extends Colleague {
public GraphicsCard(Mediator mediator) {
super(mediator);
}
public void vidoePlay(String data){
System.out.println("播放视频:"+data);
}
}
public class SoundCard extends Colleague {
public SoundCard(Mediator mediator) {
super(mediator);
}
public void playSound(String data){
System.out.println("播放音频:"+ data);
}
}
- 测试
public class IntermediaryTest {
public static void main(String[] args) {
ComputerMediator computerMediator=new ComputerMediator();
CDDevice cdDevice=new CDDevice(computerMediator);
CPUDevice cpuDevice=new CPUDevice(computerMediator);
GraphicsCard graphicsCard=new GraphicsCard(computerMediator);
SoundCard soundCard=new SoundCard(computerMediator);
computerMediator.setCpu(cpuDevice);
computerMediator.setCdDevice(cdDevice);
computerMediator.setGraphicsCard(graphicsCard);
computerMediator.setSoundCard(soundCard);
cdDevice.load();
}
}
- 结果
ComputerMediator: setCpu()-com.example.design.k_intermediary.CPUDevice@1540e19d
ComputerMediator: setCdDevice()-com.example.design.k_intermediary.CDDevice@677327b6
ComputerMediator: setGraphicsCard()-com.example.design.k_intermediary.GraphicsCard@14ae5a5
ComputerMediator: setSoundCard()-com.example.design.k_intermediary.SoundCard@7f31245a
ComputerMediator: change()-com.example.design.k_intermediary.CDDevice@677327b6
ComputerMediator: handleCD()
CPUDevice: decodeData()-视频数据
CPUDevice: decodeData()-音频数据
ComputerMediator: change()-com.example.design.k_intermediary.CPUDevice@1540e19d
ComputerMediator: handleCPU()
播放音频:音频数据
播放视频:视频数据
总结
如果一个系统中对象之间的联系呈现为网状结构,对象之间存在大量多对多关系,将导致关系及其复杂,这些对象称为“同事对象”
-我们可以引入一个中介者对象,使各个同事对象只跟中介者对象打交道,将复杂的网络结构化解为如下的星形结构
在面向对象编程中,一个类必然会与其他类产生依赖关系,当依赖关系错综复杂时,可以考虑用中介者模式进行解耦。
优点
降低类的关系复杂度,将多对多转化成一对多,实现解耦。
符合迪米特原则(最少知识原则)
缺点
中介者要做很多事,会变得庞大且难以维护。
如果本来关系并不复杂,那么使用中介者可能会让关系变得更复杂。
网友评论