设计模式（8）：中介者模式

定义：

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

 

中介者模式的类图：

Mediator：抽象中介者角色

ConcreteMediator：具体中介者角色

Colleague：同事角色

 

每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。

 

每个同事类的行为分为两种：

一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为，这种方法叫做自发行为，与其他的同事类或中介者没有任何的依赖；

一种是必须依赖中介者才能完成的行为，

 

 

优缺点：

优点就是减少了类之间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，降低耦合性。

 

缺点就是中介者会膨胀的很大，而且逻辑复杂。

 

 

示例：

进销存管理：

 

示意图：

从这个示意图中便可以看出，三个模块是相互依赖的。

修改后的类图

加入了一个中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就要通过中介者。

代码：

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定义了多个private方法，起目的是处理各个对象之间的依赖关系 * 就是说把原有的一个对象要依赖多个对象的情况转移到中介者的private方法中实现 *  * */class Mediator extends AbstractMediator {@Overridepublic void execute(String str, Object... objects) {if (str.equals("purchase.buy")) {// 采购电脑this.buyComputer((Integer) objects[0]);} else if (str.equals("sale.sale")) {// 销售电脑this.sellComputer((Integer) objects[0]);} else if (str.equals("sale.offsell")) {// 折价销售this.offsale();} else if (str.equals("stock.clear")) {this.clearStock();}}// 销售电脑private void sellComputer(Integer num) {if (super.stock.getStockNumber() < num) {// 库存数量不够销售super.purchase.buyComputer(num);}super.stock.decrease(num);}// 采购电脑private void buyComputer(Integer num) {int saleStatus = super.sale.getSaleStatus();if (saleStatus > 80) {// 销售情况良好System.out.println("采购IBM电脑 " + num + "台");super.stock.increase(num);} else {// 销售情况不好 折半采购int buyNum = num / 2;System.out.println("采购IBM电脑 " + buyNum + "台");}}// 折价销售private void offsale() {System.out.println("折价销售电脑 ： " + stock.getStockNumber() + "台");}// 清理仓库private void clearStock() {super.sale.offSale();super.purchase.refuseBuyComputer();}}abstract class AbstractColleague {protected AbstractMediator mediator;public AbstractColleague(AbstractMediator _mediator) {this.mediator = _mediator;}}class Purchase extends AbstractColleague {public Purchase(AbstractMediator _mediator) {super(_mediator);}public void refuseBuyComputer() {System.out.println("不再采购电脑");}public void buyComputer(Integer num) {super.mediator.execute("purchase.buy", num);}}class Sale extends AbstractColleague {public Sale(AbstractMediator _mediator) {super(_mediator);}public int getSaleStatus() {Random random = new Random(System.currentTimeMillis());int saleStatus = random.nextInt(100);System.out.println("电脑销售情况为 " + saleStatus);return saleStatus;}// 销售电脑public void sellComputer(int num) {super.mediator.execute("sale.sell", num);System.out.println("销售电脑" + num + "台");}// 折价销售public void offSale() {super.mediator.equals("sale.offsell");}}class Stock extends AbstractColleague {public Stock(AbstractMediator _mediator) {super(_mediator);}// 刚开始100台电脑private static int COMPUTER_NUM = 100;// 库存降低public void decrease(Integer num) {COMPUTER_NUM -= num;System.out.println("库存数量为" + COMPUTER_NUM);}public Integer getStockNumber() {return COMPUTER_NUM;}// 库存增加public void increase(Integer num) {COMPUTER_NUM += num;System.out.println("库存数量为" + COMPUTER_NUM);}// 通知采购人员不要采购,销售人员尽快销售public void clearStock() {System.out.println("清理存货数量为： " + COMPUTER_NUM);super.mediator.execute("stock.clear");}}/** * 在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性： * 只负责处理自己的活动（行为），与自己无关的活动就丢给中介者处理，程序的运行结果是相同的 加入了中介者，设计结构清晰了很多，类之间的耦合性大大减少 * */public class client {public static void main(String[] args) {AbstractMediator mediator = new Mediator();// 采购电脑System.out.println("-----------采购电脑-----------");Purchase purchase = new Purchase(mediator);purchase.buyComputer(100);// 销售电脑System.out.println("\n----------销售电脑-----------");Sale sale = new Sale(mediator);sale.sellComputer(1);// 仓库管理System.out.println("\n----------仓库管理-----------");Stock stock = new Stock(mediator);stock.clearStock();}}