springboot 使用策略模式去除过多的 if else 或 swich case！

短命女 2022-02-16 01:39 253阅读 0赞

# 一、前言 #

最近写代码的过程中，发现业务逻辑很多的时候，总会有很多的 `if ... else`，很多的 `if ...else`，有的时候就会丢去某些逻辑。有的时候也会用到`swich case` 来区分不同类型下执行不同的方法。但是往往这种情况的时候，会显得一个方法的代码非常长。为了破解这样的嵌套。我们可以使用策略模式来解决。本篇小编将通过一个示例来破解一下。

# 二、提供一个需求 #

我们这里有一个这样的需求，比如，现在有一个活动，活动根据分成了四个阶段：1-5日是预热活动，6-8日是正式活动，9-10是正式活动，11-以后是结束阶段。每个阶段要做的事情是不一样的。

当然提供最简单的思路就是：

可以通过 `swich` 或者`if ... else` 来根据不同的业务逻辑来写不同的业务代码，缺点是代码很长，不容易拓展，而且业务逻辑修改的时候会修改很多的地方。

switch (SpringGiftStepEnum.getByValue(step)) {
                case PRE_ACTIVITY:
                    //预热阶段
                    break;
                case IN_ACTIVITY:
                    //正式活动阶段
                    break;
                case IN_TASK:
                    //任务阶段
                    break;
                default:
                    //结束
                    break;
           }

# 三、使用策略模式去除过多的 if else 或 swich case！ #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpc3NjYXRmb3JldmVy_size_16_color_FFFFFF_t_70]

小编处理的业务逻辑是这样的，在service中，通过调用`handlerContext`来获取抽象类`AbstractHandler`的实例。

而项目再启动的时候，会扫描指定路径下带有我们自定义注解的类，并把类上的注解的值和类的实例作为k-v，放到`handlerContext`中。

## 图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpc3NjYXRmb3JldmVy_size_16_color_FFFFFF_t_70 1]

## HandlerProcessor，项目启动扫描handler入口 ##

HandlerProcessor：

类中指明了扫描 `com.soybean.notify.handler.biz` 路径下的，带有HandlerType注解的类。

package com.soybean.notify.handler;
    
    
    import com.google.common.collect.Maps;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    
    @Component
    @SuppressWarnings("unchecked")
    public class HandlerProcessor implements BeanFactoryPostProcessor {
    
        private static final String HANDLER_PACKAGE = "com.soybean.notify.handler.biz";
    
        /**
         * 扫描@HandlerType，初始化HandlerContext，将其注册到spring容器
         *
         * @param beanFactory bean工厂
         * @see HandlerType
         * @see HandlerContext
         */
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            Map<String, Class> handlerMap = Maps.newHashMapWithExpectedSize(3);
            ClassScaner.scan(HANDLER_PACKAGE, HandlerType.class).forEach(clazz -> {
                String type = clazz.getAnnotation(HandlerType.class).value();
                handlerMap.put(type, clazz);
            });
            HandlerContext context = new HandlerContext(handlerMap);
            beanFactory.registerSingleton(HandlerContext.class.getName(), context);
        }
    
    }

HandlerType

自定义注解

package com.soybean.notify.handler;
    
    import java.lang.annotation.*;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    public @interface HandlerType {
    
        String value();
    
    }

ClassScaner

根据包路径和注解扫描类

package com.soybean.notify.handler;
    
    import org.apache.commons.lang3.ArrayUtils;
    import org.springframework.beans.factory.BeanDefinitionStoreException;
    import org.springframework.context.ResourceLoaderAware;
    import org.springframework.core.io.Resource;
    import org.springframework.core.io.ResourceLoader;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternUtils;
    import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
    import org.springframework.core.type.classreading.MetadataReader;
    import org.springframework.core.type.classreading.MetadataReaderFactory;
    import org.springframework.core.type.filter.AnnotationTypeFilter;
    import org.springframework.core.type.filter.TypeFilter;
    import org.springframework.util.StringUtils;
    import org.springframework.util.SystemPropertyUtils;
    
    import java.io.IOException;
    import java.lang.annotation.Annotation;
    import java.util.HashSet;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Set;
    
    public class ClassScaner implements ResourceLoaderAware {
    
        private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
        private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();
    
        private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
    
        @SafeVarargs
        public static Set<Class<?>> scan(String[] basePackages, Class<? extends Annotation>... annotations) {
            ClassScaner cs = new ClassScaner();
    
            if (ArrayUtils.isNotEmpty(annotations)) {
                for (Class anno : annotations) {
                    cs.addIncludeFilter(new AnnotationTypeFilter(anno));
                }
            }
    
            Set<Class<?>> classes = new HashSet<>();
            for (String s : basePackages) {
                classes.addAll(cs.doScan(s));
            }
    
            return classes;
        }
    
        @SafeVarargs
        public static Set<Class<?>> scan(String basePackages, Class<? extends Annotation>... annotations) {
            return ClassScaner.scan(StringUtils.tokenizeToStringArray(basePackages, ",; \t\n"), annotations);
        }
    
        public final ResourceLoader getResourceLoader() {
            return this.resourcePatternResolver;
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourcePatternResolver = ResourcePatternUtils
                    .getResourcePatternResolver(resourceLoader);
            this.metadataReaderFactory = new CachingMetadataReaderFactory(
                    resourceLoader);
        }
    
        public void addIncludeFilter(TypeFilter includeFilter) {
            this.includeFilters.add(includeFilter);
        }
    
        public void addExcludeFilter(TypeFilter excludeFilter) {
            this.excludeFilters.add(0, excludeFilter);
        }
    
        public void resetFilters(boolean useDefaultFilters) {
            this.includeFilters.clear();
            this.excludeFilters.clear();
        }
    
        public Set<Class<?>> doScan(String basePackage) {
            Set<Class<?>> classes = new HashSet<>();
            try {
                String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                        + org.springframework.util.ClassUtils
                        .convertClassNameToResourcePath(SystemPropertyUtils
                                .resolvePlaceholders(basePackage))
                        + "/**/*.class";
                Resource[] resources = this.resourcePatternResolver
                        .getResources(packageSearchPath);
    
                for (int i = 0; i < resources.length; i++) {
                    Resource resource = resources[i];
                    if (resource.isReadable()) {
                        MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                        if ((includeFilters.size() == 0 && excludeFilters.size() == 0) || matches(metadataReader)) {
                            try {
                                classes.add(Class.forName(metadataReader
                                        .getClassMetadata().getClassName()));
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            } catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "I/O failure during classpath scanning", ex);
            }
            return classes;
        }
    
        protected boolean matches(MetadataReader metadataReader) throws IOException {
            for (TypeFilter tf : this.excludeFilters) {
                if (tf.match(metadataReader, this.metadataReaderFactory)) {
                    return false;
                }
            }
            for (TypeFilter tf : this.includeFilters) {
                if (tf.match(metadataReader, this.metadataReaderFactory)) {
                    return true;
                }
            }
            return false;
        }
    
    }

HandlerContext

根据类型实例化抽象类

package com.soybean.notify.handler;
    
    import java.util.Map;
    
    /**
     * @Author: 
     * @Description: 处理器上下文，根据类型获取相应的处理器
     * @Date: Created in 10:07 2019/2/2
     */
    @SuppressWarnings("unchecked")
    public class HandlerContext {
    
        private Map<String, Class> handlerMap;
    
        public HandlerContext(Map<String, Class> handlerMap) {
            this.handlerMap = handlerMap;
        }
    
        public AbstractHandler getInstance(String type) {
            Class clazz = handlerMap.get(type);
            if (clazz == null) {
                throw new IllegalArgumentException("not found handler for type: " + type);
            }
            return (AbstractHandler) BeanTool.getBean(clazz);
        }
    
    }

BeanTool

package com.soybean.notify.handler;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class BeanTool implements ApplicationContextAware {
    
        private static ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext context) throws BeansException {
            if (applicationContext == null) {
                applicationContext = context;
            }
        }
    
        public static Object getBean(String name) {
            return applicationContext.getBean(name);
        }
    
        public static <T> T getBean(Class<T> clazz) {
            return applicationContext.getBean(clazz);
        }
    
    }

AbstractHandler

抽象方法类

package com.soybean.notify.handler;
    
    import com.soybean.notify.bo.OrderBO;
    
    public abstract class AbstractHandler {
    
        abstract public String handle(OrderBO bo);
    
    }

业务类1

package com.soybean.notify.handler.biz;
    
    
    import com.soybean.notify.bo.OrderBO;
    import com.soybean.notify.handler.AbstractHandler;
    import com.soybean.notify.handler.HandlerType;
    import org.springframework.stereotype.Component;
    
    
    @Component
    @HandlerType("1")
    public class NormalHandler extends AbstractHandler {
    
        @Override
        public String handle(OrderBO bo) {
            return "处理普通订单";
        }
    
    }

业务类2

package com.soybean.notify.handler.biz;
    
    import com.soybean.notify.bo.OrderBO;
    import com.soybean.notify.handler.AbstractHandler;
    import com.soybean.notify.handler.HandlerType;
    import org.springframework.stereotype.Component;
    
    
    @Component
    @HandlerType("2")
    public class GroupHandler extends AbstractHandler {
    
        @Override
        public String handle(OrderBO bo) {
            return "处理团购订单";
        }
    
    }

业务类3

package com.soybean.notify.handler.biz;
    
    
    import com.soybean.notify.bo.OrderBO;
    import com.soybean.notify.handler.AbstractHandler;
    import com.soybean.notify.handler.HandlerType;
    import org.springframework.stereotype.Component;
    
    
    @Component
    @HandlerType("3")
    public class PromotionHandler extends AbstractHandler {
    
        @Override
        public String handle(OrderBO bo) {
            return "处理促销订单";
        }
    
    }

# 四、小结 #

策略模式的作用：就是把具体的算法实现从业务逻辑中剥离出来，成为一系列独立算法类，使得它们可以相互替换。

在我们可以通过继续写心的业务逻辑类，来拓展我们的代码，这个是非常方便的，基本serviceImpl的类中是不用修改的。可以增加新的东西，不用修改旧的东西，这个正好是设计模式里面的开闭原则。

在demo中，是通过项目开始的时候扫描指定包下的handler类，然后根据传入的type来从map中找出实例。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpc3NjYXRmb3JldmVy_size_16_color_FFFFFF_t_70]: /images/20220216/0096953a1b684f189ea5e1bfa2162b80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpc3NjYXRmb3JldmVy_size_16_color_FFFFFF_t_70 1]: /images/20220216/7fc0449ef43049f08744c207063daa0f.png