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;
//模拟客户端的测试类，（可以通过这个类来仔细研究一下中介者设计模式的具体执行流程）
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：同事角色：每一个同事角色都知道中介者角色，而且与其他同事角色进行通信的时间必须通过中介者协调。一般同事角色有两种行为，一种是自发的行为，还有一种是必须依赖与中介者的行为这是依赖方法。（具体可通过读代码）有时间我会总结一个非常通用简单的代码，放到这上面。--------------------------------------分割线 --------------------------------------编写高质量代码改善Java程序的151个建议 PDF高清完整版 http://www.linuxidc.com/Linux/2014-06/103388.htmJava 8简明教程 http://www.linuxidc.com/Linux/2014-03/98754.htmJava对象初始化顺序的简单验证 http://www.linuxidc.com/Linux/2014-02/96220.htmJava对象值传递和对象传递的总结 http://www.linuxidc.com/Linux/2012-12/76692.htmJava对象序列化ObjectOutputStream和ObjectInputStream示例 http://www.linuxidc.com/Linux/2012-08/68360.htm--------------------------------------分割线 --------------------------------------本文永久更新链接地址：http://www.linuxidc.com/Linux/2014-07/104319.htm