中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式

在现实生活中，有很多中介者模式的身影，例如QQ游戏平台，聊天室、QQ群、短信平台和房产中介。不论是QQ游戏还是QQ群，它们都是充当一个中间平台，QQ用户可以登录这个中间平台与其他QQ用户进行交流，如果没有这些中间平台，我们如果想与朋友进行聊天的话，可能就需要当面才可以了。电话、短信也同样是一个中间平台，有了这个中间平台，每个用户都不要直接依赖与其他用户，只需要依赖这个中间平台就可以了，一切操作都由中间平台去分发。

中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为

uml

角色

1.Mediator：该组件定义了与Colleague对象通信的接口。
2. ConcreteMediator :该组件通过协调Colleague对象来实现协作行为。它了解并维护其同事。
3. Colleague 抽象同事接口，定义每个Colleague所具有的行为
4. Colleague classes: 每个Colleague类都知道它的Mediator对象。每当与其他同事进行沟通时，每位同事都会与其 mediator进行沟通。

代码案例

这里我们将在聊天室应用程序的上下文中使用Mediator模式,在当人进行聊天时，如果多人之间相互通信的话，会增加类的耦合程度，增加代码复杂度，这里使用中介者模式，所有的人均与中介者通信，完成消息的发送和获取.

1. 定义Mediator接口，定义与Colleague对象通信的方法

public interface Mediator {

	/** ---------具体同事类依赖中介者的方法
	 *这种方法其实可以精简成通用的发放 sendMessage(String toColleague, message) */
	void sendMessageToColleague1(String message);

	void sendMessageToColleague2(String message);
}

2. 定义Colleague 接口,一般情况下定义为接口，这里定义为抽象类，完成特殊功能

public abstract class Colleague {

	private Mediator mediator;

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

	abstract public void receiveMessage(String message);
}

3. 具体的ConcreteMediator 类，该组件通过协调Colleague对象来实现协作行为

public class ConcreteColleague1 extends Colleague {

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

	@Override
	public void receiveMessage(String message) {
		System.out.println("colleague1收到消息: "+message);
	}

	/** ---------- self-method */
	public void selfMethod(){
		System.out.println("colleague1: 自发行为...");
	}

	public void sendMessageToColleague2(String message){
		this.getMediator().sendMessageToColleague2(message);
	}
}

public class ConcreteColleague2 extends Colleague {

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

	@Override
	public void receiveMessage(String message) {
		System.out.println("colleague2收到消息: "+message);
	}

	/** ---------- self-method */
	public void selfMethod(){
		System.out.println("colleague2: 自发行为...");
	}

	/** ---------- dependency-method */
	public void sendMessageToColleague1(String message){
		// 同事类之间不能直接交互, 同事类不能完成的工作委托给中介者完成
		this.getMediator().sendMessageToColleague1(message);
	}
}

public class ConcreteColleague3 extends Colleague {

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

	@Override
	public void receiveMessage(String message) {

	}

	public void selfMethod(){
		System.out.println("colleague3: 自发行为...");
	}

	public void sendMessageToColleague1(String message){
		this.getMediator().sendMessageToColleague1(message);
	}

	public void sendMessageToColleague2(String message){
		this.getMediator().sendMessageToColleague2(message);
	}
}

4. 测试类代码如下:

public class Client {

	public static void main(String[] args) {
		Mediator mediator = new ConcreteMediator();

		ConcreteColleague1 concreteColleague1 = new ConcreteColleague1(mediator);
		ConcreteColleague2 concreteColleague2 = new ConcreteColleague2(mediator);

		((ConcreteMediator) mediator).setColleague1(concreteColleague1);
		((ConcreteMediator) mediator).setColleague2(concreteColleague2);


		concreteColleague1.selfMethod();
		concreteColleague1.sendMessageToColleague2("来自colleague1的贺电...");

		concreteColleague2.selfMethod();
		concreteColleague2.sendMessageToColleague1("来自colleague2的贺电...");

		// 之后新增一个colleague3, 与其他同事类交互很清晰
		ConcreteColleague3 colleague3 = new ConcreteColleague3(mediator);
		colleague3.selfMethod();
		colleague3.sendMessageToColleague1("来自colleague3的贺电...");
		colleague3.sendMessageToColleague2("来自colleague3的贺电...");
	}
}