设计模式8-中介者模式

     这篇来简单学习介绍下中介者模式，所谓的中介者模式，简单的说就是所有的对象不直接进行关联，都是通过一个中间对象进行关联，有点像网络中星型模型。在下面的例子中，有采购管理，销售管理，存货管理，中介者。本来采购管理需要根据存货管理和销售管理来决定是否进行采购的；而销售管理也需要根据销售情况，看库存管理是否有货，没货需要进行采购管理；存货管理需要根据销售情况和采购情况，保存存货，保证货源充足不能过多或过少。这里引进了中介者，所有的关联都需要通过中介者来进行关联，关系图如下：

类图如下：

     建立两个抽象类AbstractMediator和AbstractColeague，每个对象只与中介者Mediator之间产生依赖，与其对象之间没有直接关系，AbstractMediator的作用是实现中介者的抽象定义，定义了一个抽象方法execute，代码如下所示：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 * 抽象中介者
 */
public abstract class AbstractMediator {
    //采购
    protected Purchase purchase;
    //销售
    protected Sale sale;
    //库存
    protected Stock stock;

    /**
     * 构造函数
     */
    public AbstractMediator() {
        this.purchase = new Purchase(this);
        this.sale = new Sale(this);
        this.stock = new Stock(this);
    }

    /**
     * 中介者最重要的方法叫做事件方法，处理多个对象之间的关系
     * @param str
     * @param objects
     */
    public abstract void execute(String str,Object ...objects);

}

   再来看具体的中介者，我们可以根据业务的要求产生多个中介者，并划分各个中介者的职责，具体中介者代码如下：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 * 具体中介者
 */
public class Mediator extends AbstractMediator{
    @Override
    public void execute(String str, Object... objects) {
        if ("purchase.buy".equals(str)){//采购电脑
            this.buyComputer((Integer) objects[0]);
        }else if ("sale.sell".equals(str)){//销售电脑
            this.sellComputer((Integer) objects[0]);
        }else if ("sale.offsell".equals(str)){//折价销售
            this.offSell();
        }else if ("stock.clear".equals(str)){//清仓处理
            this.clearStock();
        }
    }

    /**
     * 采购电脑
     * @param number
     */
    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+"台");
        }
    }

    /**
     * 销售电脑
     * @param number
     */
    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();
    }

}

     中介者Mediator定义了多个private方法，其目的是处理各个对象之间的依赖关系，就是说把原有一个对象要依赖多个对象的情况移到中介者private方法中实现。在实际项目中一般的做法是中介者按职责进行划分，每个中介者处理一个或多个类似的关联请求。

     由于使用中介者，我们增加了一个抽象同事类，三个具体的实现类分别继承该抽象类，代码如下：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 * 抽象同事类
 */
public abstract class AbstractColleague {
    protected AbstractMediator abstractMediator;
    public AbstractColleague(AbstractMediator abstractMediatorParam){
        this.abstractMediator = abstractMediatorParam;
    }
}

    采购管理的代码如下：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 * 采购管理
 */
public class Purchase extends AbstractColleague{
    public Purchase(AbstractMediator abstractMediatorParam) {
        super(abstractMediatorParam);
    }

    /**
     * 采购IBM电脑
     * @param number
     */
    public void buyIBMComputer(int number){
        super.abstractMediator.execute("purchase.buy",number);
    }

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

    库存代码如下：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 * 库存管理
 */
public class Stock extends AbstractColleague{
    //初始化电脑100台
    private static int COMPUTER_NUMBER = 100;
    public Stock(AbstractMediator abstractMediatorParam) {
        super(abstractMediatorParam);
    }

    /**
     * 库存增加
     * @param number
     */
    public void increase(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBER +number;
        System.out.println("increase库存数量为: "+COMPUTER_NUMBER);
    }

    /**
     * 库存数量为
     * @param number
     */
    public void decrease(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBER - number;
        System.out.println("decrease库存数据量为： "+COMPUTER_NUMBER);
    }

    /**
     * 获得库存数量
     * @return
     */
    public int getStockNumber(){
        return COMPUTER_NUMBER;
    }

    /**
     * 库存压力大，就要通知采购人员不要采购，销售人员尽快销售
     */
    public void clearStock(){
        System.out.println("清理存货数量为："+COMPUTER_NUMBER);
        super.abstractMediator.execute("stock.clear");
    }

}

    销售代码如下：

package com.jack.intermediary;

import java.util.Random;

/**
 * Created by jack on 2017/8/4.
 * 销售管理
 */
public class Sale extends AbstractColleague{
    public Sale(AbstractMediator abstractMediatorParam) {
        super(abstractMediatorParam);
    }

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

    /**
     * 反馈销售情况，0-100变化
     * @return
     */
    public int getSaleStatus(){
        Random random = new Random();
        int saleStatus = random.nextInt(100);
        System.out.println("IBM电脑的销售情况为： " +saleStatus);
        return saleStatus;
    }

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


}

     测试代码如下：

package com.jack.intermediary;

/**
 * Created by jack on 2017/8/4.
 */
public class MainTest5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        AbstractMediator abstractMediator = new Mediator();
        //采购人员采购电脑
        System.out.println("--------采购人员采购电脑------------");
        Purchase purchase = new Purchase(abstractMediator);
        purchase.buyIBMComputer(100);
        //销售人员销售电脑
        System.out.println("\n----------销售人员销售电脑--------------");
        Sale sale = new Sale(abstractMediator);
        sale.sellIBMComputer(1);
        //库房管理人员管理库存
        System.out.println("\n-----------------库房管理人员清库存管理----------------------");
        Stock stock = new Stock(abstractMediator);
        stock.clearStock();
    }

}

        在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动，与自己无关的活动就丢给中介者处理，程序运行的结果是相同的，从项目设计来看，加入中介者，设计结构清晰了很多，而且类间的耦合性大大减少了，代码质量也有了很大的提升。在多个对象依赖的情况下，通过加入中介者角色，取消多个对象的关联或依赖关系减少对象的耦合性。

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

       中介者模式通用类图如下：

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

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

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

     种介者模式的优点：中介者模式的优点就是减少类之间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。

    缺点：中介者模式的缺点就是中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。