设计模式-中介者模式

来源：《设计模式之禅》

定义：用一个中介者对象封装一系列对象的交互，中介者使各个对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。中介者也叫调停者模式。

组成部分：

1. 抽象中介者角色(mediator)：定义角色同意借口，用户各个同事之间的交互。

2. 具体中介者角色(concrete mediator)：实现抽象中介者角色接口，协调各个同事角色之间的交互，以来于各个同事角色。

3. 同事角色(colleague)：每个同时类都知道中介者角色，与其他同事类角色的交互，一定需要通过中介者协作。

类图：

通用代码：

抽象中介者：

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico 
 * 抽象中介者
 */
public abstract class AbstractMediator {
	protected ConcreteColleague1 colleague1;
	protected ConcreteColleague2 colleague2;
	
	public abstract void doColleague1Action();
	public abstract void doColleague2Action();

	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;
	}

}

    具体中介者：

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico
 * 具体中介者
 */
public class Mediator extends AbstractMediator {

	@Override
	public void doColleague1Action() {
		super.colleague1.doAction();
	}

	@Override
	public void doColleague2Action() {
		super.colleague2.doAction();
	}
	
}

抽象同事类：

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico
 * 抽象同事类
 */
public abstract class Colleague {
	protected AbstractMediator mediator;
	
	public Colleague(AbstractMediator mediator) {
		this.mediator = mediator;
	}
	
}

具体同事类1：

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico
 * 具体同事类1
 */
public class ConcreteColleague1 extends Colleague {

	public ConcreteColleague1(AbstractMediator mediator) {
		super(mediator);
	}
	
	public void doAction() {
		System.out.println("ConcreteColleague1.doAction......");
		
	}
	
	public void doDepend() {
		System.out.println("ConcreteColleague1.doDepend......");
		super.mediator.doColleague2Action();
	}

}

具体同事类2：

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico
 * 具体同事类2
 */
public class ConcreteColleague2 extends Colleague {

	public ConcreteColleague2(AbstractMediator mediator) {
		super(mediator);
	}
	
	public void doAction() {
		System.out.println("ConcreteColleague2.doAction......");
	}
	
	public void doDepend() {
		System.out.println("ConcreteColleague2.doDepend......");
		super.mediator.doColleague1Action();
	}

}

/**
 * 
 */
package cc.rico.pattern.mediator;

/**
 * @author rico
 *
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 中介者
		AbstractMediator mediator = new Mediator();
		
		// 同事类
		ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
		ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
		
		mediator.setColleague1(colleague1);
		mediator.setColleague2(colleague2);
		
		System.out.println("####Colleague1.doDepend...");
		colleague1.doDepend();
		
		System.out.println("###Colleague2.doDepend...");
		colleague2.doDepend();
	}

}

中介者模式优点：

     减少类之间的依赖关系，把原有一对多的依赖变成一对一的依赖，同事类只依赖中介者，降低了类间的耦合。

中介者模式缺点：

     中介者类膨胀，逻辑复杂，把原本类间的依赖关系转换为中介者与同事类间的依赖关系，同事类越多，中介者的逻辑越复杂。

使用场景：

     适用于多个对象之间紧密耦合的情况，即类图中出现了蜘蛛网结构。