设计模式——中介者

我的在CSDN的BLOG：http://blog.csdn.net/feb13/article/details/7906868

MEDIATOR 中介者

 参考《设计模式——可复用面向对象软件的基础》和《研磨设计模式》的读书笔记。

一、 意图

用一个中介者对象来封装一系列的对象交互。中介者使其各对象不须要显式地相互引用，从而使其耦合松散，并且能够独立改变它们之间的交互。

二、 适用性

• 一组对象以定义好可是复杂的方式进行通讯。产生的相互依赖关系结构混乱且难以理解。
• 一个对象引用其余很对对象而且直接与这些对象通讯，致使难以复用该对象。
• 想制定一个分布在多个类中的行为，而又不想生成太多的子类。

三、 结构

四、 参与者

Mediatord（中介者）

                            ——中介者定义一个接口用于与各同事（Colleague）对象通讯。

ConcreteMediator（具体中介者）

                            ——了解中介者经过协调各同事对象实现协做行为。

                           ——了解并维护它的各个同事。

ColleagueClass（同事类，包括其子类）

                           ——每个同事类都知道它的中介者对象。

                           ——每个同事类对象在需与其余同事通讯的时候，与它的中介者通讯。

五、 协做

同事向一个中介者对象发送和接收请求。中介者在各同事间适当地转发请求以实现协做行为。

六、 效果

1）  减小了子类生成；Mediator将本来分布于多个对象间的行为集中在一块儿。改变这些行为只须要生成Mediator的子类便可。这样各个Colleague类可被重用。

2）  它将各Colleague解耦；Mediator有利于各Colleague间的松耦合。你能够独立地改变和复用Colleague类和Mediator类。

3）  它简化了对象协议；用Mediator和各Colleague间的一对多的交互来代替多对多的交互。一对多的关系更易于理解、维护和扩展。

4）  它对对象如何协做进行了抽象；将中介做为一个独立的概念并将其封装在一个对象中，使你将注意力从对象各自自己的行为转移到它们之间的交互上来。这有助于弄清楚一个系统中的对象是如何交互的。

5）  它使控制集中化；中介者模式将交互的复杂性变为中介者的复杂性。由于中介者封装了协议，它可能变得比任一个Colleague都复杂。这可能使得中介者自身成为一个难以维护的庞然大物。

七、 实现

1）   忽略抽象的Mediator类；当各Colleague仅与一个Mediator一块儿工做时，没有必要定义一个抽象的Mediator类。Mediator类提供的抽象耦合已经使各Colleague可与不一样的Mediator子类一块儿工做，反之亦然。

2）  Colleague——Mediator通讯；当一个感兴趣的事件发生时，Colleague必须与其Mediator通讯。一种实现方法是 Observer模式，将Mediator实现为一个Observer，各Colleague做为Subset，一旦其状态改变就发送通知给 Mediator；一种方法是在Mediator中定义一个特殊的通知接口，各Colleague在通讯时直接调用该接口。

八、 代码示例

Mediatord

package com.examples.pattern.mediator;

/**
 * 中介者，定义各个同事对象通讯的接口
 */
public interface Mediator {

	/**
	 * 同事对象自身改变的时候来通知中介者的方法 让中介者去负责相应的与其余同事对象的交互
	 * 
	 * @param colleague
	 *            同事对象自身，好让中介者对象经过对象实例去得到同事对象的状态
	 */
	public void changed(Colleague colleague);
}

ConcreteMediator

package com.examples.pattern.mediator;

/**
 * 具体的中介者实现
 */
public class ConcreteMediator implements Mediator {

	/**
	 * 持有并维护同事A
	 */
	private ConcreteColleagueA colleagueA;
	/**
	 * 持有并维护同事B
	 */
	private ConcreteColleagueB colleagueB;

	/**
	 * 设置中介者须要了解并维护的同事A对象
	 * @param colleagueA
	 */
	public void setColleagueA(ConcreteColleagueA colleagueA) {
		this.colleagueA = colleagueA;
	}

	/**
	 * 设置中介者须要了解并维护的同事B对象
	 * @param colleagueB
	 */
	public void setColleagueB(ConcreteColleagueB colleagueB) {
		this.colleagueB = colleagueB;
	}

	@Override
	public void changed(Colleague colleague) {
		System.out.println(colleague);
	}

}

 Colleague Class

package com.examples.pattern.mediator;

/**   
* 同事类的抽象父类       
*/
public abstract class Colleague {

	/**
	 * 持有中介者对象，每个同事类都知道它的中介者对象
	 */
	private Mediator mediator;

	/**
	 * 构造者方法，传入中介者对象
	 * @param mediator
	 */
	public Colleague(Mediator mediator) {
		this.mediator = mediator;
	}

	/**
	 * 得到当前同事类对应的中介者对象
	 * @return
	 */
	public Mediator getMediator() {
		return mediator;
	}
	
	
	
}

package com.examples.pattern.mediator;

/**   
*  具体的同事类A      
*/
public class ConcreteColleagueA extends Colleague {

	public ConcreteColleagueA(Mediator mediator) {
		super(mediator);
	}
	
	public void someOperation(){
		//在须要跟其余同事通讯的时候，通知中介者对象
		getMediator().changed(this);
	}

}

package com.examples.pattern.mediator;

public class ConcreteColleagueB extends Colleague {

	public ConcreteColleagueB(Mediator mediator) {
		super(mediator);
	}
	
	public void someOperation(){
		//在须要跟其余同事通讯的时候，通知中介者对象
		getMediator().changed(this);
	}

}

Client

 

package com.examples.pattern.mediator;

public class Client {

	public static void main(String[] args) {
		ConcreteMediator mediator = new ConcreteMediator();
		ConcreteColleagueA ca = new ConcreteColleagueA(mediator);
		ConcreteColleagueB cb = new ConcreteColleagueB(mediator);
		
		mediator.setColleagueA(ca);
		mediator.setColleagueB(cb);
		
		ca.someOperation();
		cb.someOperation();
		
		
	}

}

九、 相关模式

Façade与中介者的不一样之处在于它是对 一个对象子系统进行抽象，从而提供了一个更方便的接口。它的协议是单向的，即Façade对象对这个子系统类提出请求，但反之则不行。相 反，Mediator提供了各Colleague对象不支持或不能支持的协做行为，并且协议是多向的。

Colleague可以使用Observer模式与Mediator通讯。

十、 广义中介者

在咱们的一般使用中，常常会简化中介者模式，来使开发变得简单，有以下变化：

• 一般会去掉同事对象的父类，这样可让任意的对象，只要须要相互交互，就能够成为同事。
• 一般不定义Mediator接口，把具体的中介者对象实现成单例。
•  同事对象再也不持有中介者，而是在须要的时候直接获取中介者对象并调用；中介者也再也不持有同事对象，而是在具体处理方法里面去建立，或者获取，或者从参数传入须要的同事对象。