Java扫包工具类

自定义Scanner工具类，用于扫包获取Class对象，

• 根据包名获取所有的class对象。
• 根据包名和指定注解的class，获取该包下所有含有该注解的class对象。
• 根据包名和指定的接口的class，获取该包下所有实现该接口的class对象。
• 使用了Map作为本地缓存，对于同一个包名不会重复读取IO资源。

package com.wang.mygateway.serviceportal.utils;

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.classreading.CachingmetadataReaderFactory;
import org.springframework.core.type.classreading.metadataReader;
import org.springframework.util.ClassUtils;

import java.lang.annotation.Annotation;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

public class Scanner {
    private static final String RESOURCE_PATTERN = "*.class";

    private static final Map>> cacheMap = new ConcurrentHashMap();

    public Scanner(){

    }

    
    public static Set> getClasses(String packageName){

        Set> cacheSet = cacheMap.get(packageName);

        if (cacheSet!=null){
            return cacheSet;
        }

        cacheSet = new HashSet<>();
        cacheMap.put(packageName,cacheSet);

        Set> handlerSet = new HashSet();

        PathMatchingResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();

        try{
            String pattern = "classpath*:"+ ClassUtils.convertClassNameToResourcePath(packageName)+RESOURCE_PATTERN;
            Resource[] resources = resourcePatternResolver.getResources(pattern);
            CachingmetadataReaderFactory readerFactory = new CachingmetadataReaderFactory(resourcePatternResolver);
            Resource[] var1 = resources;
            int var2 = resources.length;

            for (int var3 = 0; var3 < var2; ++var3){
                Resource resource = var1[var3];

                try{
                    metadataReader reader = readerFactory.getmetadataReader(resource);
                    String className = reader.getClassmetadata().getClassName();
                    Class clazz = Class.forName(className);
                    handlerSet.add(clazz);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        cacheSet.addAll(handlerSet);
        return handlerSet;
    }


    public static Set> getClassesByAnnotation(String packageName,Class cls){
        return getClassesByAnnotation(packageName,cls,true);
    }

    
    public static Set> getClassesByAnnotation(String packageName,Class cls,boolean all){
        Set> classes = getClasses(packageName);
        Set> list = classes.stream().filter(clazz -> {
            Annotation annotation = clazz.getAnnotation(cls);
            return annotation != null;
        }).collect(Collectors.toSet());

        if (!all){
            return list.stream().limit(1).collect(Collectors.toSet());
        }else{
            return list;
        }
    }

    public static Set> getClassesByInterface(String packageName,Class cls){
        return getClassesByInterface(packageName,cls,true);
    }

    
    public static Set> getClassesByInterface(String packageName,Class cls,boolean all){
        Set> classes = getClasses(packageName);
        Set> list = classes.stream().filter(clazz -> {
            Class[] interfaces = clazz.getInterfaces();
            for (Class anInterface : interfaces) {
                if (anInterface.equals(cls)){
                    return true;
                }
            }
            return false;

        }).collect(Collectors.toSet());

        if (!all){
            return list.stream().limit(1).collect(Collectors.toSet());
        }else{
            return list;
        }
    }

}