[设计模式]中介者模式

 

 

中介者模式（Mediator Pattern）也称为调解者模式或调停者模式。

 

定义：

中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用，从而使它们可以松散耦合。当某些对象之间作用发生改变

时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。中介者模式将多对多的相互作用转化为一对多的相互作用。中介

者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

 

使用场景：

当对象之间的交互操作很多且每个对象的行为操作都依赖彼此时，为防止在修改一个对象的行为时，同时涉及修改很多其他对象的行为，可采用

中介者模式，来解决紧耦合问题。该模式将对象之间的多对多关系变成一对多关系，中介者对象将系统从网状结构变成以调停者为中心的星形结构，达

到降低系统的复杂性，提高可扩展性的作用。

 

UML类图：

 

 

 

 

 

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

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

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

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

 

示例：

以电脑为例，主机部分主要分为几块：CPU、内存、显卡、IO设备，我们需要一样东西将这些零部件整合起来变成一个完整的整体，也就是主板

在这里主板就起到了中介者的作用，任何两个模块之间的通信都会经过主板去协调，以读取光盘为例，如下：

 

/**
 * 抽象中介者
 * @author Administrator
 *
 */
public abstract class Mediator {
	
	/**
	 * 同事对象改变时通知中介者的方法
	 * 在同事对象改变时由中介者去通知其他的同事对象
	 * @param c
	 */
	public abstract void changed(Colleague c);
	
	//抽象中介者中只是定义了一个抽象接口方法，具体的同事类通过该方法来通知中介者自身的状态改变。
}

/**
 * 主板中介类
 * @author Administrator
 *
 */
public class MainBoard extends Mediator {
	private CDDevice cdDevice; //光驱设备
	private CPU cpu;
	private SoundCard soundCard;
	private GraphicsCard graphicsCard;
	@Override
	public void changed(Colleague c) {
		//如果是光驱读取了数据
		if(c == cdDevice){
			handleCPU((CDDevice)c);
		} else if(c == cpu){ //如果CPU处理完数据
			handleCPU((CPU)c);
		}
			
	}
	
	private void handleCPU(CDDevice cdDevice) {
		cpu.decodeData(cdDevice.read());
	}

	/**
	 * 处理CPU读取数据后与其他设备的交互
	 * @param cpu
	 */
	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;
	}
	
	

}

/**
 * 抽象同事
 * @author Administrator
 *
 */
public abstract class Colleague {
	protected Mediator mediator; //每一个同事都该知道其中介者
	
	public Colleague(Mediator mediator){
		this.mediator = mediator;
	}
}

/**
 * 负责从主板传递来音、视频数据的解码
 * @author Administrator
 *
 */
public class CPU extends Colleague{
	private String dataVideo;
	private String dataSound;
	public CPU(Mediator mediator) {
		super(mediator);
	}
	
	/**
	 * 获取视频数据
	 * @return
	 */
	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);
		
	}

}

/**
 * 负责读取光盘的数据并将数据提供给主板
 * @author Administrator
 *
 */
public class CDDevice extends Colleague{
	private String data; //视频数据
	public CDDevice(Mediator mediator) {
		super(mediator);
	}
	
	/**
	 * 读取视频数据
	 * @return
	 */
	public String read(){
		return data;
	}
	
	/**
	 * 加载视频数据
	 */
	public void load(){
		data = "视频数据,音频数据";
		mediator.changed(this);
	}
	
	
	

}

/**
 * 显卡同事
 * @author Administrator
 *
 */
public class GraphicsCard  extends Colleague{

	public GraphicsCard(Mediator mediator) {
		super(mediator);
	}
	
	/**
	 * 播放视频
	 * @param data
	 */
	public void videoPlay(String data){
		System.out.println("视频：" + data);
	}
	
	

}

/**
 * 声卡同事
 * @author Administrator
 *
 */
public class SoundCard extends Colleague{

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

}

public class Client {
	public static void main(String[] args) {
		//构建主板对象
		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();
	}
}

运行结果：
音频： 音频数据
视频：视频数据

从程序演示中可以看出，中介者模式就是用来协调多个对象之间的交互的，就像上面示例中的主板，如果没有主板这个中介者，那么电脑里的每

 

一个零部件都要与其他零部件建立关联，这么一来主会构成一个错综复杂的网状图，而中介者模式的出现则是将这一个错综复杂的网状图变成一个

结构清晰的星形图。

 

 

总结：

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