Java中介者设计模式

中介者设计模式是一种很常见的设计模式，当中我们最为熟悉的就是我们的MVC框架。当中的C作为控制器就是一个详细的中介者，它的作用是把业务逻辑（Model），和视图（Viwe）隔离开来。使M V协调工作，把M执行的的结果和V代表的视图融合成一个前端能够展示的页面，降低M 和V的依赖关系，如今MVC框架也是一个很成熟的框架。这也是中介者模式长处的一个体现。

以下是我在书上面看过的一个样例，它的大概意思就是进销存：

如图所看到的：

通过中介者之后使得各个类之间不用相互打搅。有什么须要交互的直接通知中介者。让中介者来统一解决。

以下我通过上面这个样例用代码模拟出来，里面事实上也就解说了，中介者所起到的作用：

1:抽象中介者：

package mediator;
//这是一个抽象中介者，
public abstract class AbstractorMediator {
	protected Purchase purchase;
	protected Sale sale;
	protected Stock stock;
	//构造函数
	public AbstractorMediator(){
		purchase = new Purchase(this);
		sale = new Sale(this);
		stock = new Stock(this);
	}
	//中介者中最重要的方法 叫做事件方法，处理多个对象之间的关系。
	public abstract void execute(String str,Object...objects);
}

package mediator;
/**
 *这是抽象中介者的详细实现类，里面当中定义了多个私有方法，其目的就是为了处理各个对象之间的依赖关系。

* @author Administrator
 *
 */
public class Mediator extends AbstractorMediator{

	@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("sell.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("採购电脑的 "+ 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("折价销售电脑 "+ stock.getStockNumber());
	}

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

}

package mediator;
/**
 * 这个是同事类的抽象
 * @author Administrator
 *
 */
public class AbstractorColleague {
	protected AbstractorMediator mediator;
	public AbstractorColleague(AbstractorMediator _mediator){
		this.mediator = _mediator;
	}
}

package mediator;
//同事类的详细实现
public class Purchase extends AbstractorColleague{

	public Purchase(AbstractorMediator _mediator) {
		super(_mediator);
	}
	//採购电脑

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

	public void refuseBuyIBMcomputer(){
		System.out.println("dont buy it");
	}

}

package mediator;

import java.util.Random;

public class Sale extends AbstractorColleague{

	public Sale(AbstractorMediator _mediator) {
		super(_mediator);
	}
    //销售电脑
	public void sellIBMComputer(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");
	}
}

package mediator;

public class Stock extends AbstractorColleague{

	public Stock(AbstractorMediator _mediator) {
		super(_mediator);
	}

	private static int COMPUTER_NUM = 100;
	//添加库存数量
	public void increase(int number){
		COMPUTER_NUM = COMPUTER_NUM + number;
		System.out.println("库存数量为："+COMPUTER_NUM);
	}
	//降低库存数量
	public void decrease(int number){
		COMPUTER_NUM = COMPUTER_NUM - number;
		System.out.println("库存数量为："+COMPUTER_NUM);
	}
	//获得库存数量
	public int getStockNumber(){
		return COMPUTER_NUM;
	}
	//库存压力大了就通知 销售人员尽快销售
	public void clearStock(){
		System.out.println("清理存活数量为："+COMPUTER_NUM);
		super.mediator.execute("stock.clear");
	}
}

package mediator;
//模拟client的測试类，（能够通过这个类来细致研究一下中介者设计模式的详细运行流程）
public class Client {
	public static void main(String[] args) {
		AbstractorMediator mediator = new Mediator();
		System.out.println("採购人呀U呢採购电脑 ");
		Purchase purchase = new Purchase(mediator);
		purchase.buyIBMcomputer(100);

		System.out.println("销售人员销售电脑");
		Sale sale = new Sale(mediator);
		sale.sellIBMComputer(1);

		System.out.println("库房里人员清理库存");
		Stock stock = new Stock(mediator);
		stock.clearStock();
	}
}

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

当中主要有三部分构成：

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

2：详细中介者角色：协调各个同事角色实现协调行为，因此它必须依赖各个同事角色。

3：同事角色：每个同事角色都知道中介者角色，并且与其它同事角色进行通信的时间必须通过中介者协调。一般同事角色有两种行为，一种是自发的行为。另一种是必须依赖与中介者的行为  这是依赖方法。

（详细可通过读代码）有时间我会总结一个很通用简单的代码，放到这上面。该歇息了，明天再说吧。