在Spring环境中使用注解实现策略模式，避免过多的if-else代码

最新推荐文章于 2024-05-03 10:06:59 发布

大海_sea

最新推荐文章于 2024-05-03 10:06:59 发布

阅读量906

点赞数 1

分类专栏： Java常用框架文章标签： spring 策略模式

本文链接：https://blog.csdn.net/y506798278/article/details/116424532

版权

Java常用框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 适用场景

平时写代码，if else是经常用到的语法，是针对不同的条件，运行不同的代码。在条件分支不多的情况下，这肯定是绝佳的选择，但如果分支过多，需要写几十甚至上百的if-else，不仅可读性不好，也不利于维护。这时，可以用到策略模式。本篇文章介绍的策略模式不仅可以省去if-else的代码，还可以将不同的策略内容封装到不同的Class中，在调用不同的策略时也十分方便简洁。

2 实现思路

实现思路是这样的，将不同的策略的代码内容封装到不同的Class里面，并声明自定义注解，在每一个策略类的类名上都加上这一注解，不同的策略的注解中给不同的值；在Spring项目启动时，通过类扫描器扫描注解将对应的Class写入Spring中；需要调用具体的策略方式时，再通过从Spring的上下文对象ApplicationContext获取Class去执行不同的策略中的内容。

3 code

直接上代码了。

3.1 自定义注解

自定义注解用来标在不同的策略类上。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyType {
    String value() default "";
}

3.2 类扫描器

类扫描器相当于一个工具类，用来扫描指定包中的Class，在网上有许多类扫描器的写法，这里提供一个。

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
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.AssignableTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.ClassUtils;
import org.springframework.util.SystemPropertyUtils;
import org.springframework.util.TypeUtils;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 策略扫描器
 */
public class ClassScanner {
    private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();

    private final List<TypeFilter> includeFilters = new ArrayList<>();

    private final List<TypeFilter> excludeFilters = new ArrayList<>();

    private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);

    /**
     * 添加包含的Fiter
     * @param includeFilter TypeFilter
     */
    public void addIncludeFilter(TypeFilter includeFilter) {
        this.includeFilters.add(includeFilter);
    }

    /**
     * 扫描指定的包，获取包下所有的Class
     * @param basePackage 包名
     * @param targetTypes 需要指定的目标类型,可以是pojo,可以是注解
     * @return Set<Class<?>>
     */
    public static Set<Class<?>> scan(String basePackage, Class<?>... targetTypes) {
        ClassScanner cs = new ClassScanner();
        for (Class<?> targetType : targetTypes){
            if (TypeUtils.isAssignable(Annotation.class, targetType)) {
                cs.addIncludeFilter(new AnnotationTypeFilter((Class<? extends Annotation>) targetType));
            } else {
                cs.addIncludeFilter(new AssignableTypeFilter(targetType));
            }
        }
        return cs.doScan(basePackage);
    }

    /**
     * 扫描指定的包，获取包下所有的Class
     * @param basePackage 包名
     * @return Set<Class<?>>
     */
    public Set<Class<?>> doScan(String basePackage) {
        Set<Class<?>> classes = new HashSet<>();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                    + 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 ignore) {}
                    }
                }
            }
        } catch (IOException ex) {
            throw new RuntimeException("IO Exception!", ex);
        }
        return classes;
    }

    /**
     * 处理 excludeFilters和includeFilters
     * @param metadataReader MetadataReader
     * @return boolean
     */
    private 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;
    }
}

3.3 实现BeanFactoryPostProcessor接口

实现Spring提供的这一接口的目的是为了在Spring项目启动时，通过类扫描器去扫描注解，并将对应的Class写入Spring。

import com.bigsea.myannotation.MyType;
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.HashMap;
import java.util.Map;

@Component
public class HandlerProcessor implements BeanFactoryPostProcessor {
    /**
     * 扫描的目标类所处的包的路径
     */
    private final static String basePackage = "com.bigsea.strategy";

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        Map<String, Class> map = new HashMap<>();
        for (Class<?> aClass : ClassScanner.scan(basePackage, MyType.class)) {
            String type = aClass.getAnnotation(MyType.class).value();
            map.put(type,aClass);
        }
        beanFactory.registerSingleton(MyType.class.getName(), map);
    }
}

3.4 从Spring上下文对象中获取Class对象的类

这个类的作用就是结合之前的功能用来从Spring的上下文中获取对应的策略的Class。

import com.bigsea.myannotation.MyType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 策略上下文，从Spring中得到Class
 */
@Component
public class HandlerContext {
    @Autowired
    private ApplicationContext applicationContext;

    public AbstractHandler getInstance(String type) {
        Map<String, Class> map = (Map<String, Class>) applicationContext.getBean(MyType.class.getName());
        return (AbstractHandler)applicationContext.getBean(map.get(type));
    }
}

3.5 定义传递值的类

这一对象用来封装数据，根据type值来判断调用哪一个策略（这一个type对应MyType中的值）；并且可以在这一个对象中定义其他属性，传递属性值来实现业务功能。

/**
 * 传递数据的对象
 */
public class MyDetail {
    private String type;

    private String name;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3.6 抽象类

这一抽象类的作用是让每一个策略类都去继承它，并实现当中的方法，在调用策略处，直接调用它，来执行不同的策略。

/**
 * 抽象类
 */
public abstract class AbstractHandler {
    /**
     * 根据不同的类型处理内容
     * @param orderInfo MyDetail
     */
    public abstract void handle(MyDetail orderInfo);
}

3.7 策略

策略可以有很多个，写几十、几百，甚至几千个都可以，根据具体的业务需要来。这里我写了一个策略来举例子。

import com.bigsea.myannotation.MyType;
import com.bigsea.strategy.AbstractHandler;
import com.bigsea.strategy.MyDetail;
import org.springframework.stereotype.Component;

/**
 * 策略一
 */
@Component
@MyType("1")
public class DetailOneStrategy extends AbstractHandler {
    @Override
    public void handle(MyDetail myDetail) {
        // todo 这里可以写业务代码，需要的参数内容可以从myDetail中获取
        System.out.println("type:" + myDetail.getType());
        System.out.println("name:" + myDetail.getName());
    }
}

4 测试结果

我们用Junit进行测试，执行的结果是调用了DetailOneStrategy中的handle方法，因为这一个策略类的@MyType给的值是"1"，而在测试方法中我给的type的值也是"1"。

import com.bigsea.strategy.AbstractHandler;
import com.bigsea.strategy.HandlerContext;
import com.bigsea.strategy.MyDetail;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class StrategyTest {
    @Autowired
    private HandlerContext handlerContext;

    @Test
    public void testStrategy() {
        // todo 这里可以前端传过来的获取从数据库查出来的数据去构造对象，然后调用策略方法
        MyDetail myDetail = new MyDetail();
        myDetail.setType("1");
        myDetail.setName("一号");
        AbstractHandler handler = handlerContext.getInstance(myDetail.getType());
        handler.handle(myDetail);
    }
}

打印控制台的结果：

type:1
name:一号

大海_sea

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
在Spring环境中使用注解实现策略模式，避免过多的if-else代码

1 适用场景平时写代码，if else是经常用到的语法，是针对不同的条件，运行不同的代码。在条件分支不多的情况下，这肯定是绝佳的选择，但如果分支过多，需要写几十甚至上百的if-else，不仅可读性不好，也不利于维护。这时，可以用到策略模式。本篇文章介绍的策略模式不仅可以省去if-else的代码，还可以将不同的策略内容封装到不同的Class中，在调用不同的策略时也十分方便简洁。2 实现思路实现思路是这样的，将不同的策略的代码内容封装到不同的Class里面，并声明自...
复制链接

扫一扫