设计模式之禅--8.中介者模式

中介者模式的定义

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

中介者模式通用类图

 从类图中看，中介者模式由以下几部分组成：
● Mediator 抽象中介者角色
抽象中介者角色定义统一的接口，用于各同事角色之间的通信。
● Concrete Mediator 具体中介者角色
具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
● Colleague 同事角色
每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为（Self-Method），与其他的同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

 演示代码

今天我们的任务是设计进销存系统，听起来很像是数据库设计，不过这次是设计模式。看图：

 我们从这个示意图上可以看出，三个模块是相互依赖的。我们就以一个终端销售商（以服务最终客户为目标的企业，比如某某超市、某某商店等）为例，采购部门要采购IBM的电脑，它根据以下两个要素来决定采购数量。
● 销售情况
销售部门要反馈销售情况，畅销就多采购，滞销就不采购。
● 库存情况
即使是畅销产品，库存都有1000台了，每天才卖出去10台，也就不需要再采购了！
销售模块是企业的赢利核心，对其他两个模块也有影响：
● 库存情况
库房有货，才能销售，空手套白狼是不行的。
● 督促采购

经过需求分析，我们的攻城狮就设计出了类图。

 开始工作吧！！

1.定义库存，这是进销存的核心。

public class Stock {
	// 刚开始有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() {
		Purchase purchase = new Purchase();
		Sale sale = new Sale();
		System.out.println("清理存货数量为：" + COMPUTER_NUMBER);
		// 要求折价销售
		sale.offSale();
		// 要求采购人员不要采购
		purchase.refuseBuyIBM();

	}
}

 库房中的货物数量肯定有增减，同时库房还有一个容量显示，达到一定的容量后就要求对一些商品进行折价处理，以腾出更多的空间容纳新产品。于是就有了clearStock方法，既然是清仓处理肯定就要折价销售了。

2.库存不足要及时补充，所以不能没有采购人员

public class Purchase {

	//采购IBM型号的电脑
	public void buyIBMcomputer(int number){
		//访问库存
		Stock stock = new Stock();
		//访问销售
		Sale sale = new Sale();
		
		//电脑的销售情况
		int saleStatus = sale.getSaleStatus();
	
		if(saleStatus>80){  //销售情况良好
			System.out.println("采购IBM电脑:"+number + "台");
			stock.increase(number);
		}else{  //销售情况不好
			int buyNumber = number/2;  //折半采购
			System.out.println("采购IBM电脑："+buyNumber+ "台");
		}
	}
	
	//不再采购IBM电脑
	public void refuseBuyIBM(){
		System.out.println("不再采购IBM电脑");
	}
}

 Purchase定义了采购电脑的标准：如果销售情况比较好，大于80分，你让我采购多少我就采购多少；销售情况不好，你让我采购100台，我就采购50台，对折采购。电脑采购完毕，需要放到库房中，因此要调用库存的方法，增加库存电脑数量。

3.销售才有利润，才能给员工发工资。

public class Sale {

	// 销售IBM型号的电脑
	public void sellIBMComputer(int number) {
		// 访问库存
		Stock stock = new Stock();
		// 访问采购
		Purchase purchase = new Purchase();

		if (stock.getStockNumber() < number) { // 库存数量不够销售
			purchase.buyIBMcomputer(number);
		}
		System.out.println("销售IBM电脑" + number + "台");
		stock.decrease(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() {
		// 库房有多少卖多少
		Stock stock = new Stock();
		System.out.println("折价销售IBM电脑" + stock.getStockNumber() + "台");
	}
}

 测试一波吧！！

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

}

 

------采购人员采购电脑--------
IBM电脑的销售情况为：96
采购IBM电脑:100台
库存数量为：200

------销售人员销售电脑--------
销售IBM电脑1台
库存数量为：199

------库房管理人员清库处理--------
清理存货数量为：199
折价销售IBM电脑199台
不再采购IBM电脑
 

 运行结果也是我们期望的，三个不同类型的参与者完成了各自的活动。你有没有发现这三个类是彼此关联的？每个类都与其他两个类产生了关联关系。迪米特法则认为“每个类只和朋友类交流”，这个朋友类并非越多越好，朋友类越多，耦合性越大，要想修改一个就得修改一片，这不是面向对象设计所期望的。

那么我们重新改进一下吧！从设计图开始改进。

 

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

 重新开始工作吧!!!

1.抽象中介者，这是一切的核心。

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

再来看具体的中介者，我们可以根据业务的要求产生多个中介者，并划分各中介者的职责。 

 2.具体中介者

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方法中实现。在实际项目中，一般的做法是中介者按照职责进行划分，每个中介者处理一个或多个类似的关联请求。由于要使用中介者，我们增加了一个抽象同事类，三个具体的实现类分别继承该抽象类。

3.抽象同事类

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

4.分别实现3个同事类。

采购

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

}

 

------采购人员采购电脑--------
IBM电脑的销售情况为：52
采购IBM电脑：50台

------销售人员销售电脑--------
销售IBM电脑1台
库存数量为：99

------库房管理人员清库处理--------
清理存货数量为：99
折价销售IBM电脑99台
不再采购IBM电脑

在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动（行为），与自己无关的活动就丢给中介者处理，程序运行的结果是相同的。从项目设计上来看，加入了中介者，设计结构清晰了很多，而且类间的耦合性大大减少，代码质量也有了很大的提升。在多个对象依赖的情况下，通过加入中介者角色，取消了多个对象的关联或依赖关系，减少了对象的耦合性。

嗯！这次就比较完美了。。我们的任务也就结束了。 

中介者模式的优点

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

中介者模式的缺点

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

 中介者模式的使用场景

中介者模式简单，但是简单不代表容易使用，很容易被误用。在面向对象的编程中，对象和对象之间必然会有依赖关系，如果某个类和其他类没有任何相互依赖的关系，那这个类就是一个“孤岛”，在项目中就没有存在的必要了！就像是某个人如果永远独立生活，与任何人都没有关系，那这个人基本上就算是野人了——排除在人类这个定义之外。类之间的依赖关系是必然存在的，一个类依赖多个类的情况也是存在的，存在即合理，那是否可以说只要有多个依赖关系就考虑使用中介者模式呢？答案是否定的。中介者模式未必能帮你把原本凌乱的逻辑整理得清清楚楚，而且中介者模式也是有缺点的，这个缺点在使用不当时会被放大，比如原本就简单的几个对象依赖关系，如果为了使用模式而加入了中介者，必然导致中介者的逻辑复杂化，因此中介者模式的使用需要“量力而行”！中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。