设计模式笔记————中介者模式

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

Mediator类，抽象中介者类，如果不存在扩展情况，可以将Mediator与ConcreteMediator合二为一。

public abstract class Mediator {

	public abstract void send(String message, Colleague colleague);
}

Colleague类，抽象同事类

public abstract class Colleague {

	protected Mediator mediator;

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

ConcreteColleague类，具体同事类

public 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 receive(String message) {
		System.out.println("Colleague1 收到消息：" + message);
	}
}

public 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 receive(String message) {
		System.out.println("Colleague2 收到消息：" + message);
	}
}

ConcreteMediator类，具体中介者类。

public class ConcreteMediator extends Mediator {

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

	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.receive(message);
		}else {
			colleague1.receive(message);
		}
	}
}

客户端调用

public static void main(String[] args) {
		// TODO Auto-generated method stub		
		ConcreteMediator mediator = new ConcreteMediator();
		ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
		ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
		mediator.setColleague1(colleague1);
		mediator.setColleague2(colleague2);
		
		colleague1.send("colleague1发出了一条信息");
		colleague2.send("colleague2发出了一条信息");
	}


Colleague2 收到消息：colleague1发出了一条信息
Colleague1 收到消息：colleague2发出了一条信息

中介者模式的优缺点

优点

• 减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator
• 把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来。

缺点

• 中介者模式将交互复杂性变成了中介者的复杂性，这使ConcreteMediator会变得比任何一个ConcreteColleague都复杂

中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多子类的场合。

练习示例：美国和伊拉克之间的对话由安理会作为中介完成。

联合国类，相当于Mediator

public abstract class UnitedNations {

	public abstract void declare(String message, Country country);
}

国家类，相当于Colleague

public abstract class Country {

	protected UnitedNations mediator;

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

美国类和伊拉克类，相当于ConcreteColleague

public 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("USA getMessage :" + message);
	}
}

public 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("Iraq get message :" + message);
	}
}

安理会，相当于ConcreteMediator

public class SecurityCouncil extends UnitedNations {
	
	private USA country1;
	private Iraq country2;
	
	public void setCountry1(USA country1) {
		this.country1 = country1;
	}

	public void setCountry2(Iraq country2) {
		this.country2 = country2;
	}

	@Override
	public void declare(String message, Country country) {
		// TODO Auto-generated method stub
		if(country == country1) {
			country2.getMessage(message);
		}else {
			country1.getMessage(message);
		}
	}
}