中介者模式

Mediator Pattern
用一个调停对象来封装一系列的对象交互。调停者使
各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
简单点来说，将原来两个直接引用或者依赖的对象拆开，在中间加入一个“调停”对象，使得
两头的对象分别和“调停”对象引用或者依赖。
当然并不是所有的对象都需要加入“调停”对象。如果对象之间的关系原本一目了然，调
停对象的加入便是“画蛇添足”。
来看下调停者模式的组成部分吧。
1) 抽象调停者（Mediator）角色：抽象调停者角色定义统一的接口用于各同事角色之间的
通信。
2) 具体调停者（Concrete Mediator）角色：具体调停者角色通过协调各同事角色实现协
作行为。为此它要知道并引用各个同事角色。
3) 同事（Colleague）角色：每一个同事角色都知道对应的具体调停者角色，而且与其他
的同事角色通信的时候，一定要通过调停者角色协作。
代码套用了别人的:

package pattern.mediator;

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

package pattern.mediator;

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

package pattern.mediator;

public abstract class AbstractColleague {
	protected AbstractMediator mediator;

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

	}
}

package pattern.mediator;

public class Purchase extends AbstractColleague {

	public Purchase(AbstractMediator meditor) {
		super(meditor);
		// TODO Auto-generated constructor stub
	}

	public void buyIBMcomputer(int number) {
		super.mediator.execute("purchase.buy", number);
	}

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

package pattern.mediator;

import java.util.Random;

public class Sale extends AbstractColleague {

	public Sale(AbstractMediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}

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

	public int getSaleStatus() {
		Random rand = new Random();
		int saleStatus = rand.nextInt(100);
		System.out.println("IBM电脑的销售情况为：" + saleStatus);
		return saleStatus;
	}

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

package pattern.mediator;

public class Stock extends AbstractColleague {

	public Stock(AbstractMediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}

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

package pattern.mediator;

public class Test {
	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();
	}
}