设计模式(十八)----中介者模式

概述

用一个中介者对象封装一系列的对象交互，中介者使得各个对象不需要显式的相互作用，从而使耦合松散，还可以独立的改变他们之间的交互。属行为型模式。
中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂度。这种模式提供了一个中介类，用于处理不同类之间的通信，支持松耦合，使代码易于维护。
中介者模式结构
中介者模式又称为调停者模式，可分为三部分
抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。
中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。它需要知道所有的具体同事类，从一个具体同事类接收消息，然后通过消息影响其他具体同事类。
同事类：若一个类会影响其他类，同时也会被其他类影响，那么这两个类称为同事类。实际应用中，同事类一般是多个，它们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。每个具体同事类都只需知道自己的行为即可，但它们都需要认识中介者。

中介者对象在中介者模式中处于核心地位，因为它定义了整个系统中所有具体同事类之间的关系。在系统中主要承担两方面责任：
结构上其中转作用。通过中介者对象对关系进行封装，使得具体同事类不再需要显式的引用其他对象，只需通过中介者就可以完成与其他对象的通信。
行为上起协作作用。中介者对同事类之间的关系进行封装，同事类在不需要知道其他对象的情况下通过中介者与其他对象进行通信。在此过程中同事类不需指明中介者该如何做，中介者可根据自身逻辑进行协调，对同事的请求进一步处理，将同事成员之间的关系行为进行分离和封装。

一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种高度耦合的结构，不利于类的复用，也不稳定。若引入中介者模式，那么同事类之间的关系将变为星型结构，任何一个类的变动，只会影响类本身和中介者，这样就减少了系统耦合。一个好的设计，必定不会将所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

实例

下面的实例演示了什么是同事类：有两个类ColleagueA和ColleagueB，各有一个数字，必须保证类B中的数字永远是类A中数字的100倍。也就是说，当修改类A中的数字时，类B中的数字随之改为类A数字的100倍；修改类B中的数字时，类A中的数字随之变成类B数字除以100.类A和类B相互影响，就成为同事类。
抽象同事类

public abstract class Colleague {
	protected int num;
	//省略getter和setter方法
	//抽象方法，修改本类数字的同时修改同事类中的数字
	public abstract void setNumber(int number,Colleague colleague);
}

同事类A

public class ColleagueA extends Colleague {
	@Override 
	public void setNumber(int number,Colleague colleague) {
		num = number;
		colleague.setNum(number * 100);
	}
}

同事类B

public class ColleagueB extends Colleague {
	@Override
	public void setNumber(int number,Colleague colleague) {
		num = number;
		colleague.setNum(number / 100);
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		Colleague colleagueA = new ColleagueA();
		Colleague colleagueB = new ColleagueB();

		System.out.println("=======A影响B========");
		colleagueA.setNumber(66,colleagueB);
		System.out.println("colleagueA：" + colleagueA.getNum());
		System.out.println("colleagueB：" + colleagueB.getNum());

		System.out.println("=======B影响A========");
		colleagueB.setNumber(800,colleagueA);
		System.out.println("colleagueA：" + colleagueA.getNum());
		System.out.println("colleagueB：" + colleagueB.getNum());
	}
}

打印结果

上面的代码当中，两个类通过直接关联发生关系，若使用中介者模式，则两个类不可以直接关联，两者之间必须通过一个中介者来关联。
用中介者模式改造后的代码
抽象中介者

public abstract class AbstractMediator {
	protected Colleague A;
	protected Colleague B;
	//省略代参构造方法
	
	//修改同事类A影响同事类B的方法
	public abstract void AChangeB(); 
	//修改同事类B影响同事类A的方法
	public abstract void BChangeA();
}

中介者实现类

public class Mediator extends AbstractMediator {
	public Mediator(Colleague colleagueA,Colleague colleagueB) {
		super(colleagueA,colleagueB);
	}
	
	//处理colleagueA对colleagueB的影响
	public void AChangeB() {
		int num = colleagueA.getNum();
		colleagueB.setNum(num * 100);
	}

	//处理colleagueB对colleagueA的影响
	public void BChangeA() {
		int num = colleagueB.getNum();
		colleagueA.setNum(num / 100);
	}
}

改造抽象同事类中的setNumber方法

public abstract void setNumber(int number,AbstractMediator aMediator);

改造同事类A中的setNumber方法

public void setNumber(int number,AbstractMediator aMediator) {
	num = number;
	aMediator.AChangeB();
}

改造同事类B中的setNumber方法

public void setNumber(int number,AbstractMediator aMediator) {
	num = number;
	aMediator.BChangeA();
}

测试类

public class MediatorPatternDemo {
	public static void main(String[] args) {
		Colleague colleagueA = new ColleagueA();
		Colleague colleagueB = new ColleagueB();
		AbstractMediator abstractMediator = new AbstractMediator(colleagueA,colleagueB);
		
		System.out.println("=======A影响B========");
		colleagueA.setNumber(66,abstractMediator);
		System.out.println("colleagueA：" + colleagueA.getNum());
		System.out.println("colleagueB：" + colleagueB.getNum());

		System.out.println("=======B影响A========");
		colleagueB.setNumber(800,abstractMediator);
		System.out.println("colleagueA：" + colleagueA.getNum());
		System.out.println("colleagueB：" + colleagueB.getNum());
	}
}

打印结果

上面的代码就是将原来处理对象关系的代码重新封装到一个中介类中，通过该中介类来处理对象之间的关系。

总结

优点：适当使用中介者模式可避免同事类之间的过度耦合，使得各同事类之间可以相对独立的使用。
可将对象间一对多的关系转变成一对一的关系，使得对象间的关系易于维护。可将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。
缺点：由于中介者对象封装了系统总对象之间的相互关系，导致其变得非常复杂，使得系统维护比较困难。

适用场景
面向对象编程中，一个类必然会与其他类发生依赖关系，完全独立的类是没有意义的，一个类同时依赖多个类的情况也非常普遍，既然存在这样的情况，说明，一对多的依赖关系有其合理性。适当使用中介者模式可使原本杂乱的对象关系变得清晰，但若滥用，可能会带来相反的效果。一般来说，只有对于那种同事类之间是网状结构的复杂关系，才会考虑使用该模式，将网状结构变成星型结构。
中介者模式是一种比较常用的模式，也是一种比较容易滥用的模式。多数情况，同事类之间的关系不会复杂到混乱不堪的网状结构。因此，多数情况下，将对象的依赖关系封装到同事类内部就可以，没有必要非引入中介者模式。