中介者模式

首先说一下中介者模式的作用，再详细解说，简单的说就是一大堆类相互彼此依赖调用多对多关系，形成了网状的结构，通过中介者，各个业务类依赖中介者可以形成一对一的依赖，减少了依赖降低了类间的耦合。

中介者模式的定义：

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

通用类图如下：

从类图中可以看出，中介者模式需要三个角色：

• Mediator抽象中介者角色：

             抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

• Concrete Mediator 具体中介者角色

           具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖与各个同事角色。

• Colleague 同事角色

          每一个同事角色都知道中介者角色，在与其它同事角色通信的时候通过中介者角色协作。

中介中模式实现：

举一个很简单的例子，我们经常会做些数据交互的工作，比如我们开发了三个子系统，系统A，系统B，系统C。然后这个三个系统都是有关联的需要各自传入数据，现实中很多，我们开发一个系统接入数据或者给其它系统提供数据是很常有的事，如果各个系统直接交互会是什么样子呢，我用下面用例图实现一下：

这是一个蜘蛛网的结构，你看到后爽吗，如果再增加一个系统呢，酱紫让人怎么开发，维护。这种情况就适合用中介者模式，子系统全部中介者：

加入一个中介者作为三个各个模块的交流中心，咱们一般都称为调度，各个模块直接不再交互，交流通过中介者进行。

现在看看例子代码实现：

创建两个子系统System1 与System2 假设有两个业务 A和B

抽象中介者：

package design.mediator;

/**
 * 抽象中介者
 * @author yanwenfei
 */
public abstract class AbstractMediator {

	public System1 sys1;
	public System2 sys2;
	
	public AbstractMediator() {
		sys1 = new System1(this);
		sys2 = new System2(this);
	}
	
	//处理多个对象之间的关系
	public abstract void execute(String str, String sys);
}

具体中介者：

package design.mediator;

/**
 * 具体抽象中介者角色
 */
public class Mediator extends AbstractMediator {

	@Override
	public void execute(String str, String sys) {
		if(str.equals("A")){
			this.doThings1(sys);
		}else if(str.equals("B")){
			this.doThings2(sys);
		}
	}
	
	//业务1
	public void doThings1(String str){
		this.sys1.system1Method1(str);
		this.sys2.system2Method2(str);
	}
	
	//业务2
	public void doThings2(String str){
		this.sys2.system2Method2(str);
		this.sys1.system1Method1(str);
		
	}

}

抽象子系统：

package design.mediator;

/**
 * 抽象子系统
 * @author yanwenfei
 */
public abstract class AbstractColleague {

	protected AbstractMediator mediator;
	
	public AbstractColleague(AbstractMediator mediator) {
		this.mediator = mediator;
	}
}

具体子系统：

package design.mediator;

public class System1 extends AbstractColleague {

	public System1(AbstractMediator mediator) {
		super(mediator);
	}

	//自身功能
	public void system1Method1(String str){
		System.out.println("system1, 调用者:"+str);
	}
	
	//业务一
	public void doThings1(String str){
		super.mediator.execute("A", str);
	}
}

package design.mediator;

public class System2 extends AbstractColleague{

	public System2(AbstractMediator mediator) {
		super(mediator);
	}
	
	public void system2Method2(String str){
		System.out.println("system2, 调用者:"+str);
	}
	
	public void doThings2(String str){
		super.mediator.execute("B", str);
	}
}

测试类：

package design.mediator;

public class TestMain {

	public static void main(String[] args) {
		AbstractMediator mediator = new Mediator();
		System1 sys1 = new System1(mediator);
		sys1.doThings1("业务一");
		System2 sys2 = new System2(mediator);
		sys2.doThings2("业务二");
	}
}

执行结果：

system1, 调用者:业务一
system2, 调用者:业务一
system2, 调用者:业务二
system1, 调用者:业务二

代码写完了，从以上类发现，子系统System1 与 System2 里面的业务不需要直接相互调用，而是通过构造函数传入的中介者去调用，将具体复杂的业务让中介者实现。

中介者模式优点：

减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖。比如struts的MVC 这个很明显了 里面的C就充当了中介者，将jsp与业务逻辑分离。

中介者模式缺点

中介者会膨胀的很大，而且逻辑复杂，子系统越多，中介者的逻辑就越复杂。