【设计模式】中介者模式的实现--------java

中介者模式（Mediator）
对象之间的互相调用通过中介者来进行，降低系统的复杂性能，松耦合。

1.以同事之间的通讯为例：

package computer;

public class Test {
	public static void main(String[] args) {
		//中介者
		ConcreteMediator m=new ConcreteMediator();
		
		//让两个具体同事认识中介者
		ConcreteColleague1 colleague1=new ConcreteColleague1(m);
		ConcreteColleague2 colleague2=new ConcreteColleague2(m);
		
		//让中介者认识两个具体同事
		m.setColleague1(colleague1);
		m.setColleague2(colleague2);
		
		//具体同事通过中介者发送消息
		colleague1.send("吃饭了吗？");
		colleague2.send("没有呢，一起？");
	}
}

//抽象同事类
abstract class Colleague{
	//中介者对象
	protected Mediator mediator;
	
	//构造方法设置中介者对象是哪个
	public Colleague(Mediator mediator) {
		this.mediator=mediator;
	}
}

//抽象中介者类
abstract class Mediator{
	//抽象发送信息方法（发送的内容，发送信息的同事）
	public abstract void send(String message,Colleague colleague);
}

//具体同事1
class ConcreteColleague1 extends Colleague{
	//构造方法（语法要求必须有）
	public ConcreteColleague1(Mediator mediator) {
		super(mediator);
	}
	
	//发送信息方法（通过中介者发送）
	public void send(String message) {
		//意思是ConcreteColleague1发送信息message
		mediator.send(message, this);
	}
	
	//接收信息方法
	public void notify(String message) {
		System.out.println("同事1得到消息："+message);
	}
	
}

//具体同事2
class ConcreteColleague2 extends Colleague{
	//构造方法（语法要求必须有）
	public ConcreteColleague2(Mediator mediator) {
		super(mediator);
	}
	
	//发送信息方法（通过中介者发送）
	public void send(String message) {
		mediator.send(message, this);
	}
	
	//接收信息方法
	public void notify(String message) {
		System.out.println("同事2得到消息："+message);
	}
}

//具体中介者
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;
	}
	
	//继承的方法：判断是那个发出的消息，将消息发给另外一同事
	public void send(String message, Colleague colleague) {
		if(colleague==colleague1) {
			colleague2.notify(message);
		}else {
			colleague1.notify(message);
		}
	}
}

同事类可以在不需要知道其他对象的情况下通过中介者与其他对象完成通信，在客户端里面，同事和中介者互相认识后，同事完成通讯操作的过程中不需要告知中介者如何操作，中介者可以根据自己的逻辑结构进行协调。

2.以联合国安理会做中介者为例：

package computer;

public class Test {
	public static void main(String[] args) {
		//首先生成一个中介者：
		UnitedNationsSecurity UNSC=new UnitedNationsSecurity();
		
		//生成具体国家的时候说明该国家的中介者是谁
		//美国
		USA c1=new USA(UNSC);
		//伊拉克
		Iraq c2=new Iraq(UNSC);
		
		//设置中介者管理的额两个具体国家是谁
		UNSC.setColleague1(c1);
		UNSC.setColleague2(c2);
		
		//执行具体任务
		c1.declare("不准研发核武器，否则开战！");
		c2.delare("没并未研发核武器，开战就开战！");
	}
}

//国家类（抽象同事类）
abstract class Country{
	protected UnitedNations mediator;
	
	public Country(UnitedNations mediator) {
		this.mediator=mediator;
	}
}

//联合国机构类（抽象中介者类）
abstract class UnitedNations{
	//声明
	public abstract void declare(String message,Country colleague);
}

//美国类（具体国家类）
class USA extends Country{
	public USA(UnitedNations mediator) {
		super(mediator);
	}
	
	//声明
	public void declare(String message) {
		mediator.declare(message, this);
	}
	
	//获取消息
	public void getMessage(String message) {
		System.out.println("美国获得对方消息："+message);
	}
}

//伊拉克类（具体国家类）
class Iraq extends Country{
	public Iraq(UnitedNations mediator) {
		super(mediator);
	}
	
	//声明
	public void delare(String message) {
		mediator.declare(message, this);
	}
	
	//获取消息
	public void getMessage(String message) {
		System.out.println("伊拉克获得对方消息："+message);
	}
}

//联合国安理会类（具体中介者类）
class UnitedNationsSecurity 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;
	}
	
	//继承的方法(内容，传出者)
	public void declare(String message,Country colleague) {
		if(colleague==colleague1) {
			colleague2.getMessage(message);
		}else {
			colleague1.getMessage(message);
		}
	}
}

中介者模式的优点：将多对多通信转化为一对多通信，解耦，将控制集中，便于管理。
中介者模式缺点：控制的集中会把交互复杂性变为中介者的复杂性。
什么时候用中介者模式：一组对象之间的通信方式比较复杂。或者一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象，可以采用中介者模式。

门面模式与中介者模式对比：都是调配一组相互耦合的对象的通信。门面模式关注的是这组复杂对象如何与外界通信，中介者模式关注的是调配这组对象之间的通信。