strategy模式

场景 （1）我们可以根据不同的参数来选择一种我们想要执行的优惠计价方式

1.常规

  1. package com.example.demo.pattern.strategy;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class WithoutStrategyPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 有一个参数，是discountStyle
  10.         // 如果这个参数1，那么选择一种优惠计价的方式
  11.         // 如果这个参数2，那么选择一种优惠计价的方式
  12.         // 如果这个参数3，那么选择一种优惠计价的方式
  14.         int discountStyle = 1;
  16.         if(discountStyle == 1) {
  17.             System.out.println("执行优惠计价方式1的复杂业务逻辑"); 
  18.         } else if(discountStyle == 2) {
  19.             System.out.println("执行优惠计价方式2的复杂业务逻辑");
  20.         } else if(discountStyle == 3) { 
  21.             System.out.println("执行优惠计价方式3的复杂业务逻辑");  
  22.         } else {
  23.             System.out.println("执行默认的优惠计价方式的复杂业务逻辑");  
  24.         }
  26.         // 实际上在我们的业务代码，if else，看起来绝对不是这么短的，也不是这么简单
  27.         // 在实际的业务代码中，常见的结构是上面这样的，但是每个if和if else之间的代码行数，可能多达几十行，甚至几百行
  28.         // if和else if的判断条件，很模糊，经常就是用一堆变量的比较来判断，是走哪个分支
  30.         // 类似上面这样的代码，会让我们在代码写好以后，1年之后，回过头来看这个代码，哇塞，看到了一坨屎一样
  31.         // 看都看不懂了：代码太多了，if else if之后的条件判断，我们都看不懂，不知道在判断，if else if里面的代码，量太大了
  32.         // 定位个bug，疯了，或者是对这段代码的业务逻辑做一些改动，疯了
  33.         // 基本上，你得花个一两天的时间，把这段代码重新读一遍，然后看懂，才能下手写代码
  36.     }
  38. }

2.策略模式

  1. package com.example.demo.pattern.strategy;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class StrategryPatternDemo {
  8.     public static void main(String[] args) {
  9.         int discountStyle = 1;
  11.         DiscountCalculateStrategy strategy = DiscountCalculateStrategryFactory
  12.                 .getDiscountCalculateStrategy(discountStyle);
  14.         Context context = new Context();
  15.         context.setStrategy(strategy); 
  16.         context.calculate();
  18.         // 要点1：必须将if else的代码，封装到不同的策略类中
  19.         // 要点2：将选择哪种策略的逻辑给放到一个工厂类中去，选择策略的代码务必很简洁
  20.         // 要点3：context可有可无，具体是看你的策略执行这块如果就一行代码调用，不需要context
  21.         // 如果context中的策略执行逻辑较为复杂一点，context来封装策略类的执行逻辑
  22.     }
  24.     public interface DiscountCalculateStrategy {
  26.         void calculate();
  28.     }
  30.     public static class DiscountCalculateStrategyA implements DiscountCalculateStrategy {
  31.         @Override
  32.         public void calculate() {
  33.             System.out.println("执行优惠计价方式1的复杂业务逻辑"); 
  34.         }
  36.     }
  38.     public static class DiscountCalculateStrategyB implements DiscountCalculateStrategy {
  39.         @Override
  40.         public void calculate() {
  41.             System.out.println("执行优惠计价方式2的复杂业务逻辑"); 
  42.         }
  44.     }
  46.     public static class DiscountCalculateStrategyC implements DiscountCalculateStrategy {
  47.         @Override
  48.         public void calculate() {
  49.             System.out.println("执行优惠计价方式3的复杂业务逻辑"); 
  50.         }
  52.     }
  54.     public static class DiscountCalculateStrategyDefault implements DiscountCalculateStrategy {
  55.         @Override
  56.         public void calculate() {
  57.             System.out.println("执行默认的优惠计价方式的复杂业务逻辑"); 
  58.         }
  60.     }
  62.     public static class DiscountCalculateStrategryFactory {  
  64.         public static DiscountCalculateStrategy getDiscountCalculateStrategy(int discountStyle) {
  65.             if(discountStyle == 1) {
  66.                 return new DiscountCalculateStrategyA();
  67.             } else if(discountStyle == 2) {
  68.                 return new DiscountCalculateStrategyB();
  69.             } else if(discountStyle == 3) { 
  70.                 return new DiscountCalculateStrategyC();
  71.             } else {
  72.                 return new DiscountCalculateStrategyDefault();
  73.             }
  74.         }
  76.     }
  78.     public static class Context {
  80.         private DiscountCalculateStrategy strategy;
  82.         public DiscountCalculateStrategy getStrategy() {
  83.             return strategy;
  84.         }
  86.         public void setStrategy(DiscountCalculateStrategy strategy) {
  87.             this.strategy = strategy;
  88.         }
  90.         public void calculate() {
  91.             strategy.calculate();
  92.         }
  94.     }
  96. }

3.说明

策略模式，将会成为最最高频使用的一种设计模式，他的常见应用场景，就是替换掉那一大坨复杂难懂的if else if else。对于那种过于复杂的选择判断逻辑，完全可以将选择哪种策略的过程放到工厂里去。工厂，可以是简单工厂，也可以是工厂方法，也可以是抽象工厂。

策略模式跟命令模式的区别？看起来一样的，但是用处不一样。命令是可以发送出去，然后可以经过一些队列的流转，比如先把命令发送到MQ，接着再处理。策略是说选择了一组策略，立即就要执行的，不会经过其他别的什么处理。而且策略逻辑基本就是用在复杂的if else代码中的

命令模式，可以用在更多别的场景中

思想是不一样的，也许实现上，接口、实现类、工厂来做的，适合的场景是不一样的