设计模式之08中介者模式（笔记）

1 定义：

1.1 定义：Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.(用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。)

1.2 通用类图：

Mediator抽象中介者角色

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

Concrete Mediator具体中介者角色

协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。

Colleague同事角色

每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种方法叫做自发行为（Self-Method），与其他同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

1.3 通用代码：

	public abstract class Mediator {
		// 定义同事类
		protected ConcreteColleague1 c1;
		protected ConcreteColleague2 c2;

		// 通过getter/setter方法吧同事类注入进来
		public ConcreteColleague1 getC1() {
			return c1;
		}

		public void setC1(ConcreteColleague1 c1) {
			this.c1 = c1;
		}

		public ConcreteColleague2 getC2() {
			return c2;
		}

		public void setC2(ConcreteColleague2 c2) {
			this.c2 = c2;
		}

		// 中介者模式的业务逻辑
		public abstract void doSomething1();

		public abstract void doSomething2();
	}

	public class ConcreteMediator extends Mediator {
		@Override
		public void doSomething1() {
			// 调用同事类的方法，只要是public方法都可以调用
			super.c1.selfMethod1();
			super.c2.selfMethod2();
		}

		public void doSomething2() {
			super.c1.selfMethod1();
			super.c2.selfMethod2();
		}
	}

	public abstract class Colleague {
		protected Mediator mediator;

		public Colleague(Mediator _mediator) {
			this.mediator = _mediator;
		}
	}

	public class ConcreteColleague1 extends Colleague {
		// 通过构造函数传递中介者
		public ConcreteColleague1(Mediator _mediator) {
			super(_mediator);
		}

		// 自有方法 self-method
		public void selfMethod1() {
			// 处理自己的业务逻辑
		}

		// 依赖方法 dep-method
		public void depMethod1() {
			// 处理自己的业务逻辑
			// 自己不能处理的业务逻辑，委托给中介者处理
			super.mediator.doSomething1();
		}
	}

	public class ConcreteColleague2 extends Colleague {
		// 通过构造函数传递中介者
		public ConcreteColleague2(Mediator _mediator) {
			super(_mediator);
		}

		// 自有方法 self-method
		public void selfMethod2() {
			// 处理自己的业务逻辑
		}

		// 依赖方法 dep-method
		public void depMethod2() {
			// 处理自己的业务逻辑
			// 自己不能处理的业务逻辑，委托给中介者处理
			super.mediator.doSomething2();
		}
	}

注意：

A 在Mediator抽象类中我们只定义了同事类的get/set注入，为什么不使用抽象注入呢？这是因为同事类虽然有抽象，但是没有每个同事类必须要完成的业务方法。当然如果每个同事类都有相同的方法，比如execute 、handler等，那当然注入抽象类，做到依赖倒置。

B 为什么同事类要使用构造函数注入中介者，而中介者注入同事类只使用getter/setter方式呢？因为同事类必须有中介者，而中介者却可以只有部分同事类。

2 优点

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

3 缺点

中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

4 应用场景

类之间的联系是必然的，并非有多个依赖时就要使用中介者模式。中介者模式只适用于多个对象间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。

4.1 符合上述紧密耦合标准时使用；

4.2 N个对象之间产生了相互的依赖关系（N>2）；

4.3 多个对象有依赖关系，但是依赖的行为沿不确定或者有发生改变的可能，在这种情况下一般建议采用中介者模式，降低变更引起的风险扩散；

4.4 产品开发。一个明显的例子就是MVC框架，把中介者模式应用到产品中，可以提升产品的性能和扩展性，但是对于项目开发就未必，因为项目是以交付投产为目标，而产品则是以稳定、高效、扩展为宗旨。

生活中的使用情境：

A。机场调度中心；

B。MVC框架；

C。媒体网关；（如MSN通过服务器转发消息，而飞鸽直接使用UDP广播却不是。）

D。各种中介服务；

5 注意事项

5.1 遵循紧密耦合的标准来用中介者模式；

5.2 中介者模式很少用到接口或抽象类，这与依赖倒置原则是冲突的：首先，既然是同事类而不是兄弟类（有相同的血缘），那就说明这些类之间是协作关系，完成不同的任务，处理不同的业务，所以不能在抽象类或接口中严格定义同事类必须具有的方法。因此，如果两个对象不能提炼出共性，就不要刻意去追求两者的抽象，抽象只要定义出模式需要的角色即可。

其次，在一个项目中使用中介者模式可能被多个模块采用，每个中介者所围绕的同事类各不相同，抽象出一个具有共性的中介者也不太可能。

6 扩展

无

7 范例

（进销存案例，这三者间已形成了网状关系）

加入了一个中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就通过中介者进行。每个模块只负责自己的业务逻辑，不属于自己的则丢给中介者来处理，简化了各模块之间的耦合关系，类图如下：

	/**
	 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
	 *         all.
	 */
	public abstract class AbstractMediator {
		protected Purchase purchase;
		protected Sale sale;
		protected Stock stock;

		// 构造函数
		public AbstractMediator() {
			purchase = new Purchase(this);
			sale = new Sale(this);
			stock = new Stock(this);
		}

		// 中介者最重要的方法，叫做事件方法，处理多个对象之间的关系
		public abstract void execute(String str, Object... objects);
	}

	public class Mediator extends AbstractMediator {
		// 中介者最重要的方法
		public void execute(String str, Object... objects) {
			if (str.equals("purchase.buy")) { // 采购电脑
				this.buyComputer((Integer) objects[0]);
			} else if (str.equals("sale.sell")) { // 销售电脑
				this.sellComputer((Integer) objects[0]);
			} else if (str.equals("sale.offsell")) { // 折价销售
				this.offSell();
			} else if (str.equals("stock.clear")) { // 清仓处理
				this.clearStock();
			}
		}

		// 采购电脑
		private void buyComputer(int number) {
			int saleStatus = super.sale.getSaleStatus();
			if (saleStatus > 80) { // 销售情况良好
				System.out.println("采购IBM电脑:" + number + "台");
				super.stock.increase(number);
			} else { // 销售情况不好
				int buyNumber = number / 2; // 折半采购
				System.out.println("采购IBM电脑：" + buyNumber + "台");
			}
		}

		// 销售电脑
		private void sellComputer(int number) {
			if (super.stock.getStockNumber() < number) { // 库存数量不够销售
				super.purchase.buyIBMcomputer(number);
			}
			super.stock.decrease(number);
		}

		// 折价销售电脑
		private void offSell() {
			System.out.println("折价销售IBM电脑" + stock.getStockNumber() + "台");
		}

		// 清仓处理
		private void clearStock() {
			// 要求清仓销售
			super.sale.offSale();
			// 要求采购人员不要采购
			super.purchase.refuseBuyIBM();
		}
	}

中介者Mediator定义了多个private方法，其目的是处理各个对象之间的依赖关系，就是说把原有一个对象要依赖的多个对象的情况移动到中介者的private方法中实现。

但在实际项目中，一般的做法是中介者按照职责进行划分，每个中介者处理一个或多个类似的关联请求。

public abstract class AbstractColleague {
		protected AbstractMediator mediator;

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

	public class Purchase extends AbstractColleague {
		public Purchase(AbstractMediator _mediator) {
			super(_mediator);
		}

		// 采购IBM型号的电脑
		public void buyIBMcomputer(int number) {
			super.mediator.execute("purchase.buy", number);
		}

		// 不在采购IBM电脑
		public void refuseBuyIBM() {
			System.out.println("不再采购IBM电脑");
		}
	}

	public class Stock extends AbstractColleague {
		public Stock(AbstractMediator _mediator) {
			super(_mediator);
		}

		// 刚开始有100台电脑
		private static int COMPUTER_NUMBER = 100;

		// 库存增加
		public void increase(int number) {
			COMPUTER_NUMBER = COMPUTER_NUMBER + number;
			System.out.println("库存数量为：" + COMPUTER_NUMBER);
		}

		// 库存降低
		public void decrease(int number) {
			COMPUTER_NUMBER = COMPUTER_NUMBER - number;
			System.out.println("库存数量为：" + COMPUTER_NUMBER);
		}

		// 获得库存数量
		public int getStockNumber() {
			return COMPUTER_NUMBER;
		}

		// 存货压力大了，就要通知采购人员不要采购，销售人员要尽快销售
		public void clearStock() {
			System.out.println("清理存货数量为：" + COMPUTER_NUMBER);
			super.mediator.execute("stock.clear");
		}
	}

	public class Sale extends AbstractColleague {
		public Sale(AbstractMediator _mediator) {
			super(_mediator);
		}

		// 销售IBM型号的电脑
		public void sellIBMComputer(int number) {
			super.mediator.execute("sale.sell", number);
			System.out.println("销售IBM电脑" + number + "台");
		}

		// 反馈销售情况,0——100之间变化，0代表根本就没人卖，100代表非常畅销，出1一个卖一个
		public int getSaleStatus() {
			Random rand = new Random(System.currentTimeMillis());
			int saleStatus = rand.nextInt(100);
			System.out.println("IBM电脑的销售情况为：" + saleStatus);
			return saleStatus;
		}

		// 折价处理
		public void offSale() {
			super.mediator.execute("sale.offsell");
		}
	}

	public class Client {
		public static void main(String[] args) {
			AbstractMediator mediator = new Mediator();
			// 采购人员采购电脑
			System.out.println("------采购人员采购电脑--------");
			Purchase purchase = new Purchase(mediator);
			purchase.buyIBMcomputer(100);
			// 销售人员销售电脑
			System.out.println("\n------销售人员销售电脑--------");
			Sale sale = new Sale(mediator);
			sale.sellIBMComputer(1);
			// 库房管理人员管理库存
			System.out.println("\n------库房管理人员清库处理--------");
			Stock stock = new Stock(mediator);
			stock.clearStock();
		}
	}

在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动（行为），与自己无关的活动就丢给中介者处理。