用策略模式优化代码的实例

快来打我* 2024-01-20 08:15 49阅读 0赞

### 实例一： ###

利用利用策略模式实际开发中 if else 条件判断过多的问题，条件少还好，一旦 else if 过多这里的逻辑将会比较混乱，并很容易出错。  
比如：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70]  
刚开始条件较少，也就没管那么多直接写的；现在功能多了导致每次新增一个 else 条件都得仔细核对，生怕影响之前的逻辑。

重构之后这里的结构如下：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 1]  
最后直接变为两行代码，简洁了许多。

而之前所有的实现逻辑都单独抽取到其他实现类中。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 2]拆分后的条件执行语句![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 3]  
这样每当需要新增一个 else 逻辑，只需要新增一个类实现同一个接口便可完成。每个处理逻辑都互相独立互不干扰。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 4]  
按照目前的实现画了一个草图。

整体思路如下：

定义一个 InnerCommand 接口，其中有一个 process 函数交给具体的业务实现。  
根据自己的业务，会有多个类实现 InnerCommand 接口；这些实现类都会注册到 Spring Bean 容器中供之后使用。  
通过客户端输入命令，从 Spring Bean 容器中获取一个 InnerCommand 实例。  
执行最终的 process 函数。  
主要想实现的目的就是不在有多个判断条件，只需要根据当前客户端的状态动态的获取 InnerCommand 实例。

从源码上来看最主要的就是 InnerCommandContext 类，他会根据当前客户端命令动态获取 InnerCommand 实例。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 5]第一步是获取所有的 InnerCommand 实例列表。  
根据客户端输入的命令从第一步的实例列表中获取类类型。  
根据类类型从 Spring 容器中获取具体实例对象。  
因此首先第一步需要维护各个命令所对应的类类型。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 6]所以在之前的枚举中就维护了命令和类类型的关系，只需要知道命令就能知道他的类类型。

这样才能满足只需要两行代码就能替换以前复杂的 if else，同时也能灵活扩展。

InnerCommand instance = innerCommandContext.getInstance(msg);
    instance.process(msg) ;

**注：如果是springboot工程在获取上下文中的bean的时候可以通过如下方式：**  
方法一：

新建util类，实现ApplicationContextAware，重写setApplicationContext方法。这个方式下，工具类也被注册成了Bean，既然这样，那就必须确保该类能被Spring自动扫描到。

@Component
    public class SpringContextUtils implements ApplicationContextAware {
     
        private static ApplicationContext applicationContext;
     
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            SpringContextUtils.applicationContext = applicationContext;
        }
     
        public static <T> T getBean(Class<T> cls) {
            if (applicationContext == null) {
                throw new RuntimeException("applicationContext注入失败");
            }
            return applicationContext.getBean(cls);
        }
     
        public static Object getBean(String name) {
            if (applicationContext == null) {
                throw new RuntimeException("applicationContext注入失败");
            }
            return applicationContext.getBean(name);
        }
     
        public static <T> T getBean(String name, Class<T> cls) {
            if (applicationContext == null) {
                throw new RuntimeException("applicationContext注入失败");
            }
            return applicationContext.getBean(name, cls);
        }
     
        public static HttpServletRequest getRequest() {
            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
            return requestAttributes == null ? null : requestAttributes.getRequest();
        }
    }

方式二：

我想要的工具类，往往会部署在公共jar中，一般情况下不能被SpringBoot程序扫描到。所有就有手动注入上下文的方式。

@Slf4j
    public class SpringUtils {
     
        private SpringUtils() {
        }
     
        private static ApplicationContext context = null;
     
        /**
         * 初始化Spring上下文
         *
         * @param ctx 上下文对象
         */
        public static void initContext(ApplicationContext ctx) {
            if(ctx == null) {
                log.warn("ApplicationContext is null.");
                return;
            }
            context = ctx;
        }
     
     
        /**
         * 根据类型获取Bean
         *
         * @param cls Bean类
         * @param <T> Bean类型
         * @return Bean对象
         */
        public static <T> T getBean(Class<T> cls) {
            return context == null ? null : context.getBean(cls);
        }
     
        /**
         * 根据名称获取Bean
         *
         * @param name Bean名称
         * @return Bean对象
         */
        public static Object getBean(String name) {
            return context == null ? null : context.getBean(name);
        }
     
        /**
         * 根据Bean名称和类获取Bean对象
         *
         * @param name Bean名称
         * @param cls Bean类
         * @param <T> Bean类型
         * @return Bean对象
         */
        public static <T> T getBean(String name, Class<T> cls) {
            return context == null ? null : context.getBean(name, cls);
        }
    }

此种方式不用实现ApplicationContextAware接口，但是需要手动设置上下文。所以在程序入口处，需要调用initContext方法，完成上下文的初始化。

public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(YCloudsServiceBApplication.class, args);
        SpringUtils.initContext(context);
    }

下面展示springboot实例：

### 实例二：（Spring Boot 工程实例） ###

springUtil类如上已经建好，接口ContractStrategy和其实现类MainContractStrategy和RelieveContractStrategy类似上面实例，这里不再粘出来。下面是Enum类：

public enum ContractValidateEnum {
      
      MAIN(1,MainContractStrategy.class,"主协议校验"),
      RELIEVE(2,RelieveContractStrategy.class,"解除协议校验");
      
      private int index;
      
      private Class<? extends ContractStrategy> strategy;
      
      private String info;
      
      ContractValidateEnum(int index,Class<? extends ContractStrategy> strategy, String info) {
        this.index = index;
        this.strategy = strategy;
        this.info = info;
      }
      
      /**
       * 根据index返回对应的enum
       *
       * @param index
       * @return
       */
      public static ContractValidateEnum fromIndex(int index) {
        for (ContractValidateEnum b : ContractValidateEnum.values()) {
          if (b.getIndex() == index) {
            return b;
          }
        }
        return MAIN;
      }
      
      /**
       * @return the index
       */
      public int getIndex() {
        return index;
      }
    
    
      /**
       * @return the info
       */
      public String getInfo() {
        return info;
      }
    
      /**
       * @return the strategy
       */
      public Class<?> getStrategy() {
        return strategy;
      }
    
    }

然后是Context 类，他会根据当前客户端命令动态获取 strategy实例。

public class ContractValidateContext {
      
      public static ContractStrategy getStrategyInstance(ContractValidateEnum command){
        return (ContractStrategy) SpringUtil.getBean(command.getStrategy());
      }
    }

这里直接在Enum里面放的Class<? extends ContractStrategy>可以简化Context里面代码，当然也可以参照实例一里面放String类型的实现类的名字，再根据Class.forName()来实现。  
在使用的时候直接这样即可：

strategy = ContractValidateContext.getStrategyInstance(ContractValidateEnum.MAIN);
    strategy.execValidate("参数");

**注：本例主要是为了解决简单的策略模式不断新建对象造成的开销，这样用springBean配合静态Util类来管理实例，节省开销，提高系统性能，简化代码。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/7de9f830bfb640708c2c20a19ab4af85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/fc2bd91cad424a768878495bd5ca3674.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190614163554452.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/40ab6e19697c4e35ab9aaf64c5db8720.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/312c86e5019c45889135f9ff4d6d8ac4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/87318ced4e9c4ecab38f43ed9bdb568f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9sb25nMjIzMA_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/20/b1be07526b654f41a2159cd2aca9d6ac.png