• 中介者模式（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);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    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();

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    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电脑");

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    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");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    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");

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    测试

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

    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
  • 相关阅读:
    CISAW应急服务:网络安全应急响应之路——从经验到认证的体会
    Codeforces Round 900 (Div. 3)
    车间管理系统哪家好
    苹果电脑壁纸软件Irvue for mac激活
    Leetcode—704.二分查找【简单】
    重生之我是一名程序员 36
    为什么 GraphQL 可以取代 Redux？
    C#函数返回多个值实现实例
    Ubuntu 的护眼软件 ：RedShift
    echarts图 横向滚动条
  • 原文地址：https://blog.csdn.net/pmc0_0/article/details/126045256