设计模式-行为型模式-策略模式

一、什么是策略模式

        策略模式是一种行为设计模式，它允许在运行时选择算法或行为，并将其封装成独立的对象，使得这些算法或行为可以相互替换，而不影响使用它们的客户端。（ChatGPT生成）

        主要组成部分：

        1、策略（Strategy）： 定义了一个算法族、行为或方法，并将其封装在一个接口或抽象类中，使得这些算法可以相互替换。

        2、具体策略（Concrete Strategy）： 实现了策略接口，提供了具体的算法或行为实现。

        3、上下文（Context）： 持有一个策略对象的引用，在运行时可动态切换不同的策略。

        原理：

        1、策略模式允许在运行时动态选择算法或行为，通过将具体的算法或行为封装成策略对象，然后将这些策略对象注入到上下文中。

        2、上下文根据不同的需求或条件选择合适的策略对象，并使用它执行特定的算法或行为。

        优点：

        1、易于扩展和维护： 可以方便地添加新的策略或修改现有策略，不影响原有代码。

        2、避免条件语句： 可以避免大量的条件语句，提高代码可读性和可维护性。

        3、代码复用： 可以通过共享策略对象来提高代码的复用性。

二、场景模拟

        为了应用策略模式，我们模拟一个场景。在一个企业资源管理（ERP）系统中，可能会涉及到成本的计算，其中需要计算的成本例如：钢材、油漆、人工、运输等等，虽然说计算成本都是“单价*数量”，但是有些成本，例如钢材，不仅要计算钢材的成本，而且放置钢材或者其它费用，也需要进行一定的计费；对于人工成本，还需要计算企业担负的五险一金等。

 如上图所示，钢材是由吨数*单价计算的，但是要考虑保管费或其他费用，假设一吨n元，后续还可能考虑其它费用等；人工费用，雇员一人可能工资12000元，公司要负担其12%公积金或者医疗保险等；运输要考虑车辆维护费或者日常损耗。（以上仅是模拟，真实环境可能更加复杂或简单）。

三、业务实现

3.1、使用IF-ELSE方法

public static BigDecimal useIfElse(String name, BigDecimal amount, BigDecimal price){

        if (name.equals("plate")) {
            // 单价×数量，再加上每吨200元的其它费用
            return amount.multiply(price).add(amount.multiply(new BigDecimal("200.00")));
        } else if (name.equals("paints")) {
            // 单价×数量，再加上每吨200元的其它费用
            return amount.multiply(price).add(amount.multiply(new BigDecimal("100.00")));
        } else if (name.equals("employer")) {
            // 人员×数量，再加上每吨200元的其它费用
            BigDecimal sum = amount.multiply(price); // 基本工资
            sum = sum.add(amount.multiply(price.multiply(new BigDecimal("0.12")))); // 加上额外支付的12%公积金
            return sum;
        } else if (name.equals("haulage")) {
            // 吨数×数量，再加上每吨300元的损耗费用
            return amount.multiply(price).add(amount.multiply(new BigDecimal("300.00")));
        } else {
            log.error("无法匹配");
            return new BigDecimal(0);
        }

    }

我们用IF-ELSE方法，确实是可以实现功能，可以看出来很麻烦，看起来很混乱，没有结构，也没办法实现一些定制功能，后续变动起来也比骄困难，因为有一些东西都是写死的。我们来测试一下：

public static void main(String[] args) {

        // 钢板单价及数量
        BigDecimal plateAmount = new BigDecimal(15);
        BigDecimal platePrice = new BigDecimal("888.88");

        // 油漆价格及数量
        BigDecimal paintsAmount = new BigDecimal(20);
        BigDecimal paintsPrice = new BigDecimal("490.00");

        // 雇员工资及人数
        BigDecimal employerAmount = new BigDecimal(10);
        BigDecimal employerPrice = new BigDecimal("10000.00");

        // 运输价格及吨数
        BigDecimal haulageAmount = new BigDecimal(25);
        BigDecimal haulagePrice = new BigDecimal("3000.00");

        // 计算各个成本
        BigDecimal plate = useIfElse("plate", plateAmount, platePrice);
        BigDecimal paints = useIfElse("paints", paintsAmount, paintsPrice);
        BigDecimal employer = useIfElse("employer", employerAmount, employerPrice);
        BigDecimal haulage = useIfElse("haulage", haulageAmount, haulagePrice);

        BigDecimal sum = plate.add(paints).add(employer).add(haulage);

        log.info("钢材:{}元,油漆{}元,雇员:{}元,运输:{}元,总计:{}元", plate, paints, employer, haulage, sum);

    }

可以看到确实正确的计算出了结果，但是这种方式不具有拓展性，随着程序功能的增加，会越来越混乱。那有些同学可能会说，为什么不用Switch-Case方法？那就来实践一下。

3.2、使用Switch-Case方法

public static BigDecimal useSwitch(String name, BigDecimal amount, BigDecimal price){

        switch (name) {
            case "plate":
                // 单价×数量，再加上每吨200元的其它费用
                return amount.multiply(price).add(amount.multiply(new BigDecimal("200.00")));
            case "paints":
                // 单价×数量，再加上每吨200元的其它费用
                return amount.multiply(price).add(amount.multiply(new BigDecimal("100.00")));
            case "employer":
                // 人员×数量，再加上每吨200元的其它费用
                BigDecimal sum = amount.multiply(price); // 基本工资
                sum = sum.add(amount.multiply(price.multiply(new BigDecimal("0.12")))); // 加上额外支付的12%公积金
                return sum;
            case "haulage":
                // 吨数×数量，再加上每吨300元的损耗费用
                return amount.multiply(price).add(amount.multiply(new BigDecimal("300.00")));
            default:
                log.error("无法匹配");
                return new BigDecimal(0);
        }

    }

使用Switch-Case方法后，确实代码变得比较清晰了，但是一些东西仍然是写死的，不具备很好的扩展性。

3.3、使用策略模式重构代码

        其中ICosts是一个接口，里面只有一个方法，就是成本的计算。他的实现类包含钢材、油漆、人工等等，可以有很多。Context是策略控制类，外部可以传递不同策略执行计算成本方法。

 3.3.1、编写成本计算接口

public interface ICosts<T, K, V> {

    /**
     * 成本计算
     * @param amount 数量
     * @param price 单价
     * @param other 其它信息
     * @return 成本金额
     */
    BigDecimal calculateCosts(T amount, BigDecimal price, Map<K, V> other);
}

 解释一下amount为什么要用T表示，因为这里数量不仅仅是BigDecimal形式的，可能会涉及到人、车辆等等，这种是没有小数点的……；关于other就是一些附加信息，例如钢材的除锈费用、维护费用，人员的五险一金比例等等。

3.3.2、具体成本实现类

钢材

public class GCCosts implements ICosts<BigDecimal, String, BigDecimal> {

    /*
    * 钢材成本
    *   1、基本成本：吨数 * 价格；
    *   2、存放成本：吨数 * 存放消费；
    *   3、防锈成本：吨数 * 防锈成本；
    * */
    @Override
    public BigDecimal calculateCosts(BigDecimal amount, BigDecimal price, Map<String, BigDecimal> other) {

        BigDecimal sum = amount.multiply(price);

        // 计算存放成本
        if (other.containsKey("CF")) {
            sum = sum.add(amount.multiply(other.get("CF")));
        }
        // 计算防锈成本
        if (other.containsKey("CX")) {
            sum = sum.add(amount.multiply(other.get("CX")));
        }

        return sum;
    }
}

油漆

public class YQCosts implements ICosts<BigDecimal, String, BigDecimal> {

    /*
    * 油漆成本
    *   1、基础成本：单价 * 数量；
    *   2、存放成本： 数量 * 存放费用；
    * */
    @Override
    public BigDecimal calculateCosts(BigDecimal amount, BigDecimal price, Map<String, BigDecimal> other) {

        BigDecimal sum = amount.multiply(price);

        if (other.containsKey("CF")) {
            sum = sum.add(amount.multiply(other.get("CF")));
        }

        return sum;
    }
}

人工

public class RGCosts implements ICosts<Long, String, BigDecimal> {

    /*
    * 人工成本：
    *   1、基础成本：人数 * 工资；
    *   2、公积金成本： 人数 * （工资 * 公积金比例）；
    *   3、五险成本：人数 * （工资 * 企业分摊比例）；
    * */
    @Override
    public BigDecimal calculateCosts(Long amount, BigDecimal price, Map<String, BigDecimal> other) {

        // 先计算每个人成本
        BigDecimal personCosts = price;

        // 加公积金
        if (other.containsKey("GJJ")) {
            personCosts = personCosts.add(price.multiply(other.get("GJJ")));
        }

        // 加五险
        if (other.containsKey("BX")) {
            personCosts = personCosts.add(price.multiply(other.get("BX")));
        }

        return personCosts.multiply(BigDecimal.valueOf(amount)); // 计算总成本
    }
}

运输

public class YSCosts implements ICosts<BigDecimal, String, BigDecimal> {

    /*
    * 运输成本：
    *   1、基础成本：运输数量 * 运输单价；
    *   2、损耗费用：例如换机油，养护等费用，固定金额（模拟）；
    * */
    @Override
    public BigDecimal calculateCosts(BigDecimal amount, BigDecimal price, Map<String, BigDecimal> other) {

        BigDecimal sum = amount.multiply(price);

        // 加上固定的养护费用
        if (other.containsKey("YH")) {
            sum = sum.add(other.get("YH"));
        }

        return sum;
    }
}

3.3.3、成本策略控制类

public class CostsContext<T, K, V>{

    private ICosts<T, K, V> iCosts;

    public CostsContext(ICosts<T, K, V> iCosts) {
        this.iCosts = iCosts;
    }

    public BigDecimal calculateCosts(T amount, BigDecimal price, Map<K, V> other) {
        return iCosts.calculateCosts(amount, price, other);
    }
}

此类充当一个调度作用，不同的成本计算就选择不同的实现类，然后执行calculateCosts()方法。

3.3.4、测试

public static void main(String[] args) {

        // 钢板单价及数量
        BigDecimal plateAmount = new BigDecimal(15);
        BigDecimal platePrice = new BigDecimal("888.88");
        Map<String, BigDecimal> plateMap = new HashMap<String, BigDecimal>(){{
            put("CF", new BigDecimal("300"));
            put("CX", new BigDecimal("200"));
        }};

        // 油漆价格及数量
        BigDecimal paintsAmount = new BigDecimal(20);
        BigDecimal paintsPrice = new BigDecimal("490.00");
        Map<String, BigDecimal> paintsMap = new HashMap<String, BigDecimal>(){{
            put("CF", new BigDecimal("300"));
        }};

        // 雇员工资及人数
        // BigDecimal employerAmount = new BigDecimal(10);
        Long employerAmount = 10L;
        BigDecimal employerPrice = new BigDecimal("10000.00");
        Map<String, BigDecimal> employerMap = new HashMap<String, BigDecimal>(){{
            put("GJJ", new BigDecimal("0.12"));
            put("BX", new BigDecimal("0.06"));
        }};

        // 运输价格及吨数
        BigDecimal haulageAmount = new BigDecimal(25);
        BigDecimal haulagePrice = new BigDecimal("3000.00");
        Map<String, BigDecimal> haulageMap = new HashMap<String, BigDecimal>(){{
            put("YH", new BigDecimal("1500"));
        }};

        // 使用策略模式计算
        // 钢材
        CostsContext<BigDecimal, String, BigDecimal> plateCost = new CostsContext<>(new GCCosts());
        BigDecimal plate = plateCost.calculateCosts(plateAmount, platePrice, plateMap);

        // 油漆
        CostsContext<BigDecimal, String, BigDecimal> paintsCost = new CostsContext<>(new YQCosts());
        BigDecimal paints = paintsCost.calculateCosts(paintsAmount, paintsPrice, paintsMap);

        // 人工
        CostsContext<Long, String, BigDecimal> employerCost = new CostsContext<>(new RGCosts());
        BigDecimal employer = employerCost.calculateCosts(employerAmount, employerPrice, employerMap);

        // 运输
        CostsContext<BigDecimal, String, BigDecimal> haulageCost = new CostsContext<>(new YQCosts());
        BigDecimal haulage = haulageCost.calculateCosts(haulageAmount, haulagePrice, haulageMap);

        BigDecimal sum = plate.add(paints).add(employer).add(haulage);

        log.info("钢材:{}元,油漆{}元,雇员:{}元,运输:{}元,总计:{}元", plate, paints, employer, haulage, sum);

    }

上面是一些各种成本的数量和单价信息，同时使用Map存放了一些特有的成本信息，然后下面我们使用成本策略控制类CostsContext装载不同的实现类来进行成本的计算。

可以看到成功的计算出了结果。我们不仅实现了功能，也为后续的扩展打下了良好的基础，例如后续加新的成本类型进行计算，我们只需要继承ICosts实现不同的方法即可，如果某一个类型的计算加了一些条件，这样我们直接在Map里面添加条件，并在相应的实体类进行处理即可，这样让我们的代码结构变得清晰。

四、小结 

        if-else是我们初学代码时就接触到的代码，伴随我们走过了很多年，但是我们的思维一定要有提高，不要一有需求，就想到if-else，确实，if-else可以快速地实现功能，我们不可否认，但是随着项目复杂度的提高，if-else已经无法满足我们的需求，它会让我们的代码变得臃肿、复杂、结构混乱，所以我们就想到要用其它方法来替代if-else，让我们整个代码结构变得清晰。

        上面我们介绍了使用策略模式来代替一堆的if-else，策略模式的优点远不止如此：

        1、具有强的扩展性，例如我们扩充新的成本计算，只需要新建类并实现接口即可；

        2、易维护和理解，如何我么要看或者修改钢材的成本计算，我们不用到一堆if-else里面去找具体的代码块，我们只需要进去相应的实现类去看就可以，代码清晰明了，没有其他代码的干扰（体现出隔离性），我们维护起来也得心应手；

        3、使用策略模式可以让我们代码变得优美，思维能力和架构水平得到提升。