设计模式之中介者模式

中介者模式

• 定义：

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

• 使用场景：

  1. 一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用中介者模式。可以将网状结构变为星状结构，使同事类之间的关系变的清晰一些。
  2. 当有多个对象彼此间相互交互的时候，自然就会想到对象间的耦合度过高，解决办法就是封装对象间的交互行为，因此就能想到中介者模式就是干这行的。

• UML：

  1. Mediator：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象的事件方法，并由子类去实现。
  2. ConcreteMediator：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。
  3. Colleague：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

• 优点：

  1. 适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。
  2. 使用中介者模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。
  3. 使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

• 缺点：

  1. 过度使用或者滥用中介者模式可能会造成同事类间的关系复杂化，导致系统维护起来很困难。
  2. 承担的责任比较大，不方便管理和维护。

• 样例：

  abstract class AbstractColleague {
  	protected int number;
   
  	public int getNumber() {
  		return number;
  	}
   
  	public void setNumber(int number){
  		this.number = number;
  	}
  	//注意这里的参数不再是同事类，而是一个中介者
  	public abstract void setNumber(int number, AbstractMediator am);
  }
   
  class ColleagueA extends AbstractColleague{
   
  	public void setNumber(int number, AbstractMediator am) {
  		this.number = number;
  		am.AaffectB();
  	}
  }
   
  class ColleagueB extends AbstractColleague{
   
  	@Override
  	public void setNumber(int number, AbstractMediator am) {
  		this.number = number;
  		am.BaffectA();
  	}
  }
   
  abstract class AbstractMediator {
  	protected AbstractColleague A;
  	protected AbstractColleague B;
  	
  	public AbstractMediator(AbstractColleague a, AbstractColleague b) {
  		A = a;
  		B = b;
  	}
   
  	public abstract void AaffectB();
  	
  	public abstract void BaffectA();
   
  }
  class Mediator extends AbstractMediator {
   
  	public Mediator(AbstractColleague a, AbstractColleague b) {
  		super(a, b);
  	}
   
  	//处理A对B的影响
  	public void AaffectB() {
  		int number = A.getNumber();
  		B.setNumber(number*100);
  	}
   
  	//处理B对A的影响
  	public void BaffectA() {
  		int number = B.getNumber();
  		A.setNumber(number/100);
  	}
  }
   
  public class Client {
  	public static void main(String[] args){
  		AbstractColleague collA = new ColleagueA();
  		AbstractColleague collB = new ColleagueB();
  		
  		AbstractMediator am = new Mediator(collA, collB);
  		
  		System.out.println("==========通过设置A影响B==========");
  		collA.setNumber(1000, am);
  		System.out.println("collA的number值为："+collA.getNumber());
  		System.out.println("collB的number值为A的10倍："+collB.getNumber());
   
  		System.out.println("==========通过设置B影响A==========");
  		collB.setNumber(1000, am);
  		System.out.println("collB的number值为："+collB.getNumber());
  		System.out.println("collA的number值为B的0.1倍："+collA.getNumber());
  		
  	}
  }