设计模式（java) ------ 中介者模式

场景：设计一个电脑采购管理模块

该模块中主要包括三个部分：

1. 采购管理

2. 销售管理

3. 存货管理

需要根据以下要素来决定采购数量

销售情况：销售部门反馈销售情况，畅销就多采购，滞销就不采购

库存情况：库房有货，才能销售

督促采购：若购买的数量大于库存数量，就需要提醒采购部门及时采购物品

中介者模式

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

中介者模式主要包括以下几个部门：

1.Mediator抽象中介者角色

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

2.Concrete Mediator 具体中介者角色

具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色

3.Colleague 同事角色

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

场景问题解决类图

主要涉及如下几个角色：

1.采购管理

2.库存管理

3.销售管理

4.抽象中介者

5.具体中介者

6.抽象同事类

7.场景类

代码实现：

Purchase:

public class Purchase extends AbstractColleague {

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

}

Sale:

public class Sale extends AbstractColleague {

	public Sale(AbstractMediator mediator) {
		super(mediator);
	}
	
	public void sellIBMComputer(int number) {
		super.mediator.execute("sale.sell", number);
	}
	
	public int getSaleStatue() {
		Random random = new Random(System.currentTimeMillis());
		int saleStatues = random.nextInt(100);
		return saleStatues;
	}
	
	public void offSale() {
		
	}

}

Stock:

public class Stock extends AbstractColleague{
	
	private static int COMPUTER_NUMBER = 100;       //初始化库存

	public Stock(AbstractMediator _mediator) {
		super(_mediator);
	}
	
	//库存增加
	public void increase(int number) {          
		COMPUTER_NUMBER += number;
	}
	
	//库存减少
	public void decrease(int number) {
		COMPUTER_NUMBER -= number;
	}
	
	//获得库存数量
	public int getStockNumber() {
		return COMPUTER_NUMBER;
	}
	
	//
	public void clearStock() {
		System.out.println("清理存货数量为:" + COMPUTER_NUMBER);
		super.mediator.execute("stock.clear");
	}
	
	

}

AbstractMediator

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

}

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 status = super.sale.getSaleStatue();
		if (status > 80) {
			System.out.println("采购电脑" + number + "台");
		}else {
			System.out.println("折半采购电脑"+ (number/2) + "台");
		}
	}
	
	//销售电脑
	private void sellComputer(int number) {
		if (super.stock.getStockNumber() < number) {
			super.purchase.buyIMBComputer(number);
		}
		super.stock.decrease(number);
	}
	
	//折价销售电脑
	private void offSell() {
		System.out.println("折扣销售电脑"+ super.stock.getStockNumber()+ "台");
	}
	
	//清理库存
	private void clearStock() {
		super.sale.offSale();
		super.purchase.refuseBuyIBM();
	}

}

AbstractColleague:

public abstract class AbstractColleague {
	
	protected AbstractMediator mediator;

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