中介者模式（Mediator）

问题引入

我们从这个示意图上可以看出，三个模块是相互依赖的。我们就以一个终端销售商为例：

采购部门要采购IBM的电脑，它根据以下两个要素来决定采购数量。

• 销售情况：销售部门要反馈销售情况，畅销就多采购，滞销就不采购。
• 库存情况：即使是畅销产品，库存都有1000台了，每天才卖出去10台，也不需要采购了！

销售模块是企业的赢利核心，对其他两个模块也有影响：

• 库存情况：库房有货，才能销售，空手套白狼是不行的。
• 督促采购：在特殊情况下，比如一个企业客户要一次性购买100台电脑，库存只有80台，这时需要催促采购部门赶快采购！

库存管理也对其他两个模块有影响：

• 库房是有容积限制的，不可能无限大，所以就有了清仓处理，那就要求采购部门停止采购
• 同时销售部门进行打折销售。

---

模式引入

解决方案

类图

中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就通过中介者进行。每个模块只负责自己的业务逻辑，不属于自己的则丢给中介者来处理，简化了各模块之间的耦合关系

package mediator;

/** * @author pangjian * @ClassName AbstractMediator * @Description 抽象中介者，关联着其他具体实现同事类，也可以做一个容器去管理这些成员变量 * @date 2022/7/28 21:26 */

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

    }
    /** * @Description: Object...是不限制参数，可以为0，也可以为多个 * @Param str: * @Param objects: * @return void * @date 2022/7/28 22:03 */
    public abstract void execute(String str,Object...objects);

}

package mediator;

/** * @author pangjian * @ClassName Mediator * @Description 可以通知父类关联的同事类去执行相应的方法，私有方法是同事类关联的事件，自发事件是在各自的同事实现类上 * @date 2022/7/28 21:35 */

public class Mediator extends AbstractMediator {
    

    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 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+"台");
        }

    }

    // 销售电脑
    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();

    }
}

package mediator;

/** * @author pangjian * @ClassName Purchase * @Description 具体同事类，单一职责，只负责自发行为，关联行为放到中介者中 * @date 2022/7/28 21:29 */

public class Purchase extends AbstractColleague{
    

    public Purchase(AbstractMediator mediator){
    

        super(mediator);

    }


    //采购IBM电脑
    public void buyIBMcomputer(int number){
    

        super.mediator.execute("purchase.buy", number);

    }

    //不再采购IBM电脑
    public void refuseBuyIBM(){
    

        System.out.println("不再采购IBM电脑");

    }

}

package mediator;

import java.util.Random;

/** * @author pangjian * @ClassName Sale * @Description 具体同事类，单一职责，只负责自发行为，关联行为放到中介者中 * @date 2022/7/28 21:32 */

public class Sale extends AbstractColleague {
    

    public Sale(AbstractMediator mediator){
    

        super(mediator);

    }

    // 销售IBM电脑
    public void sellIBMComputer(int number){
    

        super.mediator.execute("sale.sell", number);

        System.out.println("销售IBM电脑"+number+"台");

    }

    // 反馈销售情况，0～100之间变化，0代表根本就没人买，100代表非常畅销，出一个卖一个
    public int getSaleStatus(){
    

        Random rand=new Random(System.currentTimeMillis());

        int saleStatus=rand.nextInt(100);

        System.out.println("IBM电脑的销售情况为："+saleStatus);

        return saleStatus;

    }

    // 折价处理
    public void offSale(){
    

        super.mediator.execute("sale.offsell");
    }
}

package mediator;

/** * @author pangjian * @ClassName Stock * @Description 抽象同事类 * @date 2022/7/28 21:31 */

public class Stock extends AbstractColleague{
    

    public Stock(AbstractMediator mediator){
    

        super(mediator);

    }

    // 刚开始有100台电脑
    private static int COMPUTER_NUMBER=100;

    // 库存增加
    public void increase(int number){
    

        COMPUTER_NUMBER=COMPUTER_NUMBER+number;

        System.out.println("库存数量为："+COMPUTER_NUMBER);

    }

    // 库存降低
    public void decrease(int number){
    

        COMPUTER_NUMBER=COMPUTER_NUMBER-number;

        System.out.println("库存数量为："+COMPUTER_NUMBER);

    }

    // 获得库存数量
    public int getStockNumber(){
    

        return COMPUTER_NUMBER;

    }

    //存货压力大了，就要通知采购人员不要采购，销售人员要尽快销售
    public void clearStock(){
    

        System.out.println("清理存货数量为："+COMPUTER_NUMBER);

        super.mediator.execute("stock.clear");

    }

}

---

测试

package mediator;

/** * @author pangjian * @ClassName Client * @Description TODO * @date 2022/7/28 22:08 */

public class Client {
    

    public static void main(String[]args){
    

        AbstractMediator mediator = new Mediator();

        //采购人员采购电脑
        System.out.println("------采购人员采购电脑--------");
        Purchase purchase=new Purchase(mediator);
        purchase.buyIBMcomputer(100);

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

        //库房管理人员管理库存
        System.out.println("\n------库房管理人员清库处理--------");
        Stock stock=new Stock(mediator);
        stock.clearStock();

    }
    
}