设计模式（十四）——中介者模式

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

abstract class Mediator{   //抽象中介者类
	public abstract void Send(String message,Colleague colleague);
}
abstract class Colleague{        //抽象同事类
	protected Mediator mediator;
	public Colleague(Mediator mediator) {
		this.mediator=mediator;
	}
}
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);
		}
	}
	
}
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 Main {
	public static void main(String[] args) {
		ConcreteMediator m=new ConcreteMediator();
		ConcreteColleague1 c1=new ConcreteColleague1(m);
		ConcreteColleague2 c2=new ConcreteColleague2(m);
		m.setColleague1(c1);
		m.setColleague2(c2);
		c1.Send("吃过饭了吗？");
		c2.Send("没有呢，你打算请客？");
	}
}

二、例：安理会做中介

abstract class UnitedNations { // 联合国机构类，相当于Mediator类
	public abstract void Declare(String message, Country colleague);
}

abstract class Country { // 国家类，相当于Colleague类
	protected UnitedNations mediator;

	public Country(UnitedNations meditor) {
		this.mediator = mediator;
	}
}

class USA extends Country { // 美国类，相当于ConcreteColleague1类

	public USA(UnitedNations meditor) {
		super(meditor);
		// TODO Auto-generated constructor stub
	}

	public void Declare(String message) {
		mediator.Declare(message, this);
	}

	// 获得消息
	public void GetMessage(String message) {
		System.out.println("美国获得对方信息:" + message);
	}
}

class Iraq extends Country { // 伊拉克类，相当于ConcreteColleague2类

	public Iraq(UnitedNations meditor) {
		super(meditor);
		// TODO Auto-generated constructor stub
	}

	public void Declare(String message) {
		mediator.Declare(message, this);
	}

	// 获得消息
	public void GetMessage(String message) {
		System.out.println("美国获得对方信息:" + message);
	}
}

class UnitedNationsSecurityCounci1 extends UnitedNations { // 联合国安全安理会，相当于ConcreteMediator类
	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 Main {
	public static void main(String[] args) {
		UnitedNationsSecurityCounci1 UNSC = new UnitedNationsSecurityCounci1();
		USA c1 = new USA(UNSC);
		Iraq c2 = new Iraq(UNSC);
		c1.Declare("不准研制核武器，否则要发动战争！");
		c2.Declare("我们没有核武器，也不怕侵略。");
	}
}

三、中介者模式优缺点
优点：减少了各个Colleague的耦合，使得可以独立的改变和复用各个Colleague类和Mediator。
缺点：由于ConcreteMediator控制了集中化，于是把交互复杂性变为了中介者的复杂性，使得中介者变得比任何一个ConcreteColleague都复杂。