设计模式——中介者

1.定义

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

2.使用场景

1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

例如：1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。

3.实现

/**
 * 抽象同事类：规定了具体同事需要实现的方法
 * @author Administrator
 *
 */
public abstract class Colleague {
	protected String name;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public Colleague(String name) {
		this.name = name;
	}
	
	public abstract void sendMessage(Mediator mediator,String message);
	
	public abstract String receiveMessage(String message);
	
}

/**
 * 中介者接口：定义一个接口用于各同事(Colleague)之间的通信
 * @author Administrator
 *
 */
public interface Mediator {
	void deliverMessage(Colleague colleague,String message);
}

/**
 * 具体同事类：实现抽象类的方法，每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。
 * @author Administrator
 *
 */
public class ColleagueA extends Colleague{

	public ColleagueA(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void sendMessage(Mediator mediator, String message) {
		// TODO Auto-generated method stub
		mediator.deliverMessage(this, message);
	}

	@Override
	public String receiveMessage(String message) {
		// TODO Auto-generated method stub
		System.out.println("我的名字："+super.name+",收到消息："+message);
		return null;
	}

}

/**
 * 具体同事类：实现抽象类的方法，每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。
 * @author Administrator
 *
 */
public class ColleagueB extends Colleague{

	public ColleagueB(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void sendMessage(Mediator mediator, String message) {
		// TODO Auto-generated method stub
		mediator.deliverMessage(this, message);
	}

	@Override
	public String receiveMessage(String message) {
		// TODO Auto-generated method stub
		System.out.println("我的名字："+super.name+",收到消息："+message);
		return null;
	}

}

/**
 * 具体中介者：具体中介者，实现抽象中介者的方法，具体中介者需要包含所有具体同事（ConcreteColleague）的引用，并通过实现中介者接口中的方法来满足具体同事之间的通信要求；
 * @author Administrator
 *
 */
public class ConcreteMediator implements Mediator{
	private Colleague colleagueA;
	private Colleague colleagueB;
	
	public ConcreteMediator(Colleague colleagueA,Colleague colleagueB) {
		this.colleagueA = colleagueA;
		this.colleagueB = colleagueB;
	}

	@Override
	public void deliverMessage(Colleague colleague, String message) {
		// TODO Auto-generated method stub
		if(colleague==colleagueA) {//如果是A发来的消息，那么通知B
			colleagueB.receiveMessage(message);
		}else if(colleague==colleagueB) {//如果是B发来的消息，那么通知A
			colleagueA.receiveMessage(message);
		}
	}

}

/**
 * 测试类
 * @author Administrator
 *
 */
public class Test {
	public static void main(String[] args) {
		Colleague colleagueA = new ColleagueA("客户");
		Colleague colleagueB = new ColleagueB("商家");
		
		Mediator mediator = new ConcreteMediator(colleagueA,colleagueB);
		
		colleagueA.sendMessage(mediator, "我需要一份三明治");
		colleagueB.sendMessage(mediator, "这里有各种各样的三明治");
	}
}

运行结果：

4.总结

主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。
缺点： 中介者会庞大，变得复杂难以维护。