与枚举结合的策略模式

枚举类：

 package com.dtranx.tools.corpora.businessapi.enums;

import com.dtranx.tools.commons.vo.EnumResponseVo;
import com.google.common.collect.Lists;

import java.util.List;

/**
 * @ClassName SimpleSearchMode
 * @Description TODO
 * @Date 2024/5/28 15:55
 * @Author ly
 **/
public enum SimpleSearchMode {
    TM(1,"TM","语料库"),
    RTM(2,"RTM","反选库"),
    STM(3,"STM","这个项目对应选择的参考库里有STM标签的语料库的结果"),
    TM_STM(4,"TM_STM","语料库的基础上只查参考库中包含STM标签的结果"),
    RTM_STM(5,"RTM_STM","反选库的基础上只查参考库中包含STM标签的结果");

    private int value;

    private String code;

    private String desc;

    SimpleSearchMode(int value, String code, String desc) {
        this.value = value;
        this.code = code;
        this.desc = desc;
    }

    public static List<EnumResponseVo> getEnums(){
        SimpleSearchMode[] values = SimpleSearchMode.values();
        List<EnumResponseVo> enumResponseVos = Lists.newArrayList();
        for(int i = 0;i<values.length;i++){
            EnumResponseVo build = EnumResponseVo.builder()
                    .value(values[i].value)
                    .code(values[i].code)
                    .desc(values[i].desc).build();
            enumResponseVos.add(build);
        }
        return enumResponseVos;
    }
}

抽象策略：

package com.dtranx.tools.corpora.business.strategy.matchmode;

import com.dtranx.tools.commons.util.ScanSupport;
import com.dtranx.tools.corpora.abilityapi.req.MatchingReqVo;
import com.dtranx.tools.corpora.business.service.LibraryBusinessInfoService;
import com.dtranx.tools.corpora.businessapi.enums.SimpleSearchMode;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;

import java.util.Map;
import java.util.Set;

/**
 * @ClassName AbstractMatchMode
 * @Description TODO
 * @Date 2024/5/30 18:24
 * @Author ly
 **/
@Slf4j
public abstract class AbstractMatchMode {

    protected static final Map<SimpleSearchMode, AbstractMatchMode> SEARCH_MODE = Maps.newHashMap();


    static{
        Class clazz = AbstractMatchMode.class;
        Set<Class<?>> classes = null;
        try {
            classes = ScanSupport.classInfos(clazz.getPackage().getName());
        } catch (Exception e) {
            log.error("扫描搜索模式策略失败:",e);
        }
        if(CollectionUtils.isNotEmpty(classes)) {
            for (Class<?> aClass : classes) {
                if(ScanSupport.validate(aClass.getSuperclass(),clazz)){
                    try {
                        AbstractMatchMode abstractModeStrategy = (AbstractMatchMode) aClass.newInstance();
                        SimpleSearchMode mode = abstractModeStrategy.getMode();
                        SEARCH_MODE.put(mode,abstractModeStrategy);
                    } catch (Exception e) {
                        log.error("初始化搜索模式策略失败:",e);
                    }
                }
            }
        }
    }

    public static void handleMatchReqVo(SimpleSearchMode simpleSearchMode,MatchingReqVo matchingReqVo, LibraryBusinessInfoService libraryBusinessInfoService){
        if(simpleSearchMode == null) {
            return;
        }
        AbstractMatchMode matchMode = SEARCH_MODE.get(simpleSearchMode);
        if(matchMode == null){
            return;
        }
        matchMode.handleMatchReqVo(matchingReqVo,libraryBusinessInfoService);
    }


    /**
     * 处理MatchingReqVo
     * @param matchingReqVo
     * @param libraryBusinessInfoService
     */
    protected abstract void handleMatchReqVo(MatchingReqVo matchingReqVo, LibraryBusinessInfoService libraryBusinessInfoService);

    /**
     * 获取搜索类型
     * @return
     */
    protected abstract SimpleSearchMode getMode();

}

具体策略：

package com.dtranx.tools.corpora.business.strategy.matchmode;

import com.dtranx.tools.corpora.abilityapi.req.MatchingReqVo;
import com.dtranx.tools.corpora.business.service.LibraryBusinessInfoService;
import com.dtranx.tools.corpora.businessapi.enums.SimpleSearchMode;

/**
 * @ClassName TmMatchMode
 * @Description TODO
 * @Date 2024/5/30 18:29
 * @Author ly
 **/
public class RtmMatchMode extends AbstractMatchMode{

    @Override
    protected void handleMatchReqVo(MatchingReqVo matchingReqVo, LibraryBusinessInfoService libraryBusinessInfoService) {
        matchingReqVo.setIds(null);
    }

    @Override
    protected SimpleSearchMode getMode() {
        return SimpleSearchMode.RTM;
    }
}

类扫描工具：

package com.dtranx.tools.commons.util;

import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
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.util.ClassUtils;
import org.springframework.util.SystemPropertyUtils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


/**
 * @ClassName ScanSupport
 * @Description TODO
 * @Date 2022/5/17 10:34
 * @Author ly
 */
public class ScanSupport implements ResourceLoaderAware {
    /**
     * Spring容器注入
     */
    private ResourceLoader resourceLoader;

    private ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
    private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);

    /**
     * set注入对象
     */
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    /**
     * 利用spring提供的扫描包下面的类信息,再通过classfrom反射获得类信息
     * 
     * @param scanPath
     * @return
     * @throws IOException
     */
    public Set<Class<?>> doScan(String scanPath) throws Exception {
        Set<Class<?>> classes = new HashSet<Class<?>>();
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                .concat(ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(scanPath))
                        .concat("/**/*.class"));
        Resource[] resources = resolver.getResources(packageSearchPath);
        MetadataReader metadataReader = null;
        for (Resource resource : resources) {
            if (resource.isReadable()) {
                metadataReader = metadataReaderFactory.getMetadataReader(resource);
                try {
                    // 当类型不是抽象类或接口在添加到集合
                    if (metadataReader.getClassMetadata().isConcrete()) {
                        classes.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
                    }
                } catch (Exception e) {
                    throw e;
                }
            }
        }
        return classes;
    }

    /**
     * 指定包下面的类信息
     * 
     * @return 多个类信息
     */
    public static Set<Class<?>> classInfos( String path) throws Exception {
        try {
            return new ScanSupport().doScan(path);
        } catch (Exception e) {
           throw e;
        }
    }

    /**
     * 验证父类
     * @param aClass
     * @param targetClass
     * @return
     */
    public static Boolean validate(Class<?> aClass,Class<?> targetClass){
        if(aClass.equals(targetClass)){
            return true;
        }
        if(aClass.equals(Object.class)){
            return false;
        }
        return validate(aClass.getSuperclass(),targetClass);
    }

    /**
     * 获取模型的字段
     * @param targetClass
     * @param fields
     */
    public static void getDeclaredFields(Class targetClass, List<Field> fields){
        if(targetClass == null || Object.class.equals(targetClass)){
            return;
        }
        Field[] declaredFields = targetClass.getDeclaredFields();
        if(declaredFields != null && declaredFields.length > 0){
            for(int i = 0;i<declaredFields.length;i++){
                fields.add(declaredFields[i]);
            }
        }
        getDeclaredFields(targetClass.getSuperclass(),fields);
    }

}