设计模式学习笔记——08 中介者模式

中介者模式

Mediator模式也叫中介者模式，Mediator模式是行为模式之一，在Mediator模式中，类之间的交互行为被统一放在Mediator的对象中，对象通过Mediator对象同其他对象交互，Mediator对象起着控制器的作用。MVC中的C控制器就是一个中介者，它将M业务逻辑和V视图隔离开，把M运行的结果和V代表的视图融合成一个前端可以展示的页面，减少M和V的依赖关系。

优点

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

缺点

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

使用场景

N个对象中间产生了相互依赖的关系（N>3）
多个对象有依赖关系，但依赖的行为尚不确定或者有发生改变的可能

下面的例子源于设计模式之禅这本书，先放上UML类图

public abstract class AbstractColleague {

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

public class Purchase extends AbstractColleague{

	Purchase(AbstractMediator mediator){
		super(mediator);
	}
	public void buyComputer(int number){
		super.mediator.execute("purchase.buy", number);
	}
	public void refuseBuyComputer(){
		System.out.println("不再采购IBM电脑");
	}
}

public class Sale extends AbstractColleague{

	Sale(AbstractMediator mediator) {
		super(mediator);
	}

	public void sellComputor(int number){
		super.mediator.execute("sale.sell", number);
		System.out.println("共卖出电脑" + number + "台");
	}

	public int getSaleStatus(){
		Random rand = new Random(System.currentTimeMillis());
		int saleStatus = rand.nextInt(100);
		System.out.println("销售量：" + saleStatus);
		return saleStatus;
	}
	
	public void offSale(){
		super.mediator.execute("sale.offsell");
	}
}

public class Stock extends AbstractColleague{

	Stock(AbstractMediator mediator) {
		super(mediator);
	}

	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 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{

	@Override
	public void execute(String str, Object... objects) {
		if(str.equals("purchase.buy")){
			this.buyComputer((Integer)objects[0]);
		}else if(str.equals("sale.sell")){
			this.sellCoptomer((Integer)objects[0]);		
		}else if(str.equals("stock.clear")){
			this.clearStock();		
		}else if(str.equals("sale.offsell")){
			this.offSell();		
		}
		
	}

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

	private void clearStock() {
		super.sale.offSale();
		super.purchase.refuseBuyComputer();
	}

	private void sellCoptomer(int number) {
		if(super.stock.getStockNumber()< number){
			super.purchase.buyComputer(number);
		}
		super.stock.decrease(number);
		
	}

	private void buyComputer(int number) {
		int saleStatus = super.sale.getSaleStatus();
		if(saleStatus>80){
			System.out.println("采购" + number + "台");
		}else{
			int buyNumber = number/2;
			System.out.println("采购" + number + "台");
		}
		
	}

}

public class Client {

	public static void main(String[] args) {
		AbstractMediator mediator = new Mediator();
		Purchase purchase = new Purchase(mediator);
		Sale sale = new Sale(mediator);
		Stock stock = new Stock(mediator);
		purchase.buyComputer(100);
		sale.sellComputor(10);
		stock.clearStock();

	}

}