中介者模式（Mediator）

一、中介者模式介绍

1.中介者模式（Mediator）：
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互。
2.结构图：

介绍：Mediator：抽象中介者，定义各个同事角色之间通信的接口，ConcreateMediator：具体的中介者，依赖相关的具体同事，Colleague：抽象同事，定义公共同事的接口。ConcreateColleague：具体的同事类，和其他同事通信通过中介角色。每个同事类有两种行为，一种是本身的行为，一种是依赖中介的行为。
###########################################
3.代码
Mediator类 抽象中介者类

 //抽象中介类
abstract class Mediator{
	public abstract void Send(String message,Colleague colleague);
}

Colleague类 抽象同事类

//抽象同事类
abstract class Colleague{
	protected Mediator mediator;
	public Colleague(Mediator mediator) {//构造方法，得到中介者对象
		this.mediator=mediator;
	}
}

ConcreteMediator类 具体中介者类

//具体中介类
class ConcreteMediator extends Mediator{
	private ConcreteColleague1 colleague1;
	private ConcreteColleague2 colleague2;
	//需要了解所以的具体同事对象
	public ConcreteColleague1 getColleague1() {
		return colleague1;
	}

	public void setColleague1(ConcreteColleague1 colleague1) {
		this.colleague1 = colleague1;
	}

	public ConcreteColleague2 getColleague2() {
		return colleague2;
	}

	public void setColleague2(ConcreteColleague2 colleague2) {
		this.colleague2 = colleague2;
	}

	@Override
	public void Send(String message, Colleague colleague) {
		// TODO Auto-generated method stub
		if(colleague==colleague1) {
			colleague2.Notify(message);
		}else {
			colleague1.Notify(message);
		}
	}
	
}

ConcreteColleague1和ConcreteColleague2等各种同事对象

//抽象同事类
abstract class Colleague{
	protected Mediator mediator;
	public Colleague(Mediator mediator) {
		this.mediator=mediator;
	}
}
class ConcreteColleague1 extends Colleague{

	public ConcreteColleague1(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Send(String message) {
		mediator.Send(message, this);
	}
	public void Notify(String message) {
		System.out.println("同事1得到的信息："+message);
	}
}
class ConcreteColleague2 extends Colleague{

	public ConcreteColleague2(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Send(String message) {
		mediator.Send(message, this);
	}
	public void Notify(String message) {
		System.out.println("同事2得到的信息："+message);
	}
}

客户端调用

//客户端调用
public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConcreteMediator m=new ConcreteMediator();
		ConcreteColleague1 c1=new ConcreteColleague1(m);
		ConcreteColleague2 c2=new ConcreteColleague2(m);
		m.setColleague1(c1);
		m.setColleague2(c2);
		c1.Send("你吃饭了吗？");
		c2.Send("还没呢，你请客不？");
	}

}

二、中介者模式责任

中介者对象定义了整个系统中所有具体同事类之间的关系，处于核心地位。在整个系统中它主要承担两个方面的责任:

• 结构上起到中转作用。通过中介者对象对关系的封装，使得具体的同事类不再需要显示的引用其他对象，通过中介者就可以完成与其他同事类之间的通信。

• 行为上起到协作作用。中介者对同事类之间的关系进行封装，同事类在不需要知道其他对象的情况下通过中介者与其他对象完成通信。在这个过程中同事类不需要指明中介者该如何做，中介者可以根据自身的逻辑进行协调，对同事的请求进一步处理，将同事成员之间的关系行为进行分离和封装。

由于有了Mediator对对象的关系进行了封装，使得ConcreteColleague1和 ConcreteColleague2在发送消息和接收消息时通过中介者来完成，减少了同事类之间的耦合度，使得他们可以独立改变和复用。

三、具体应用中介者模式——安理会做中介

1、结构图：

###############################################
2、代码：

package 中介者模式;

//联合国机构 相当于Mediator类
abstract class UnitedNations{
	public abstract void Declare(String message,Country colleague);
}
//国家类 相当于colleague类
abstract class Country{
	protected UnitedNations mediator;
	public Country(UnitedNations mediator) {
		this.mediator=mediator;
	}
}
//美国类 相当于ConcreteColleague1类
class USA extends Country{

	public USA(UnitedNations mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Declare(String message) {
		mediator.Declare(message, this);
	}
	public void GetMessage(String message) {
		System.out.println("美方获得对方信息："+message);
	}
}
//伊拉克类 相当于ConcreteColleague2类
class Iraq extends Country{

	public Iraq(UnitedNations mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Declare(String message) {
		mediator.Declare(message, this);
	}
	public void GetMessage(String message) {
		System.out.println("伊拉克获得对方信息："+message);
	}
}
//联合国安全理事会 相当于ConcreteMediator类
class UnitedNationsSecurityCouncil extends UnitedNations{
	private USA colleague1;
	private Iraq colleague2;
	public USA getColleague1() {
		return colleague1;
	}

	public void setColleague1(USA colleague1) {
		this.colleague1 = colleague1;
	}

	public Iraq getColleague2() {
		return colleague2;
	}

	public void setColleague2(Iraq colleague2) {
		this.colleague2 = colleague2;
	}

	@Override
	public void Declare(String message, Country colleague) {
		// TODO Auto-generated method stub
		if(colleague==colleague1) {
			colleague2.GetMessage(message);
		}else {
			colleague1.GetMessage(message);
		}
	}
	
}

//客户端调用
public class Main2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		UnitedNationsSecurityCouncil m=new UnitedNationsSecurityCouncil();
		USA c1=new USA(m);
		Iraq c2=new Iraq(m);
		m.setColleague1(c1);
		m.setColleague2(c2);
		c1.Declare("不准研制核武器，否则要发动战争！");
		c2.Declare("我们没有核武器，也不怕侵略。");
	}

}

//显示结果：
伊拉克获得对方信息，不允许颜值核武器，否则要发动战争。
美国获得对方信息，我们没有核武器，也不怕侵略。

4.优点：

• Mediator模式是一种很有用并且很常用的模式，它将对象间的通信封装到一个类中，将多对多的通信转化为一对多的通信，降低了系统的复杂性。
• Mediator还获得系统解耦的特性，通过Mediator，各个Colleague就不必维护各自通信的对象和通信协议，降低了系统的耦合性，Mediator和各个Colleague就可以相互独立地修改了。
• Mediator模式还有一个很显著的特点就是将控制集中,集中的优点就是便于管理，也正符合了OO设计中的每个类的职责要单一和集中的原则

5、缺点：
控制的集中化把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个C oncreteC olleague都复杂。