获取指定包下使用指定注解相关的类、方法、字段

通过对指定包下的所有类文件进行扫描，获取使用指定注解的所有类、方法、字段

工具类

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.DefaultResourceLoader;
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.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.util.ClassUtils;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by IntelliJ IDEA.
 * User: 贝先 [ Cason mo ]
 * Date: 2022/6/29
 * Time: 10:45
 */
public class AnnotationUtils {

    private static final Logger logger = LoggerFactory.getLogger(AnnotationUtils.class);
    static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
    private static AnnotationUtils mInstance;
    private static final ReentrantLock LOCKER = new ReentrantLock();

    /**
     * 单例模式获取AnnotationUtils
     *
     * @return
     */
    public static AnnotationUtils getInstance() {
        if (mInstance == null) {
            LOCKER.lock();
            if (mInstance == null) {
                mInstance = new AnnotationUtils();
            }
            LOCKER.unlock();
        }
        return mInstance;
    }

    public List<Class<?>> getClassCandidates(String basePackages, Class clazz) {
        List<Class<?>> candidates = scanPackagesForClass(basePackages, clazz);
        validateCandidates(basePackages, candidates.isEmpty());
        return candidates;
    }

    public List<Method> getMethodCandidates(String basePackages, Class clazz) {
        List<Method> candidates = scanPackagesForMethod(basePackages, clazz);
        validateCandidates(basePackages, candidates.isEmpty());
        return candidates;
    }

    public List<Field> getFieldCandidates(String basePackages, Class clazz) {
        List<Field> candidates = scanPackagesForField(basePackages, clazz);
        validateCandidates(basePackages, candidates.isEmpty());
        return candidates;
    }

    public List<Class<?>> scanPackagesForClass(String basePackages, Class clazz) {
        List<Class<?>> candidates = new ArrayList<Class<?>>();
        try {
            candidates.addAll(findCandidateClasses(basePackages, clazz));
        } catch (IOException e) {
            logger.error("扫描指定包时出现异常", basePackages);
        }
        return candidates;
    }

    public List<Method> scanPackagesForMethod(String basePackages, Class clazz) {
        List<Method> candidates = new ArrayList<Method>();
        try {
            candidates.addAll(findCandidateMethod(basePackages, clazz));
        } catch (IOException e) {
            logger.error("扫描指定包时出现异常", basePackages);
        }
        return candidates;
    }

    public List<Field> scanPackagesForField(String basePackages, Class clazz) {
        List<Field> candidates = new ArrayList<Field>();
        try {
            candidates.addAll(findCandidateField(basePackages, clazz));
        } catch (IOException e) {
            logger.error("扫描指定包时出现异常", basePackages);
        }
        return candidates;
    }

    public List<Class<?>> findCandidateClasses(String basePackage, Class clazz) throws IOException {
        List<Class<?>> candidates = new ArrayList<Class<?>>();
        String packageSearchPath = getPackageSearchPath(basePackage);
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        MetadataReaderFactory readerFactory = new SimpleMetadataReaderFactory(resourceLoader);
        Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources(packageSearchPath);
        for (Resource resource : resources) {
            MetadataReader reader = readerFactory.getMetadataReader(resource);
            if (match(reader.getClassMetadata(), clazz)) {
                Class<?> candidateClass = transform(reader.getClassMetadata().getClassName());
                if (candidateClass != null) {
                    candidates.add(candidateClass);
                    logger.debug("扫描到符合要求的类：" + candidateClass.getName());
                }
            }
        }
        return candidates;
    }

    public List<Method> findCandidateMethod(String basePackage, Class clazz) throws IOException {
        List<Method> candidates = new ArrayList<Method>();
        String packageSearchPath = getPackageSearchPath(basePackage);
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        MetadataReaderFactory readerFactory = new SimpleMetadataReaderFactory(resourceLoader);
        Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources(packageSearchPath);
        for (Resource resource : resources) {
            MetadataReader reader = readerFactory.getMetadataReader(resource);
            matchMethod(clazz, candidates, reader);
        }
        return candidates;
    }

    public List<Field> findCandidateField(String basePackage, Class clazz) throws IOException {
        List<Field> candidates = new ArrayList<Field>();
        String packageSearchPath = getPackageSearchPath(basePackage);
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        MetadataReaderFactory readerFactory = new SimpleMetadataReaderFactory(resourceLoader);
        Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources(packageSearchPath);
        for (Resource resource : resources) {
            MetadataReader reader = readerFactory.getMetadataReader(resource);
            matchField(clazz, candidates, reader);
        }
        return candidates;
    }

    private void matchMethod(Class clazz, List<Method> candidates, MetadataReader reader) {
        Class<?> clz = transformToClass(reader.getClassMetadata().getClassName());
        Method[] methods = clz.getMethods();
        for (Method method : methods) {
            Annotation annotation = method.getAnnotation(clazz);

            if (annotation == null) {
                continue;
            }
            if (method != null && method.isAnnotationPresent(clazz)) {
                candidates.add(method);
                logger.debug("扫描到符合要求的method：" + method.getName());
            }
        }
    }

    private void matchField(Class clazz, List<Field> candidates, MetadataReader reader) {
        Class<?> clz = transformToClass(reader.getClassMetadata().getClassName());
        Field[] declaredFields = clz.getDeclaredFields();
        for (Field field : declaredFields) {
            Annotation annotation = field.getAnnotation(clazz);

            if (annotation == null) {
                continue;
            }
            if (field != null && field.isAnnotationPresent(clazz)) {
                candidates.add(field);
                logger.debug("扫描到符合要求的field：" + field.getName());
            }
        }
    }

    public String convertPath(String path) {
        return StringUtils.replace(path, ".", "/");
    }

    public Class<?> transform(String className) {
        Class<?> clazz = null;
        try {
            clazz = ClassUtils.forName(className, this.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            logger.info("未找到指定类", className);
        }
        return clazz;
    }

    public boolean match(ClassMetadata metadata, Class c) {
        Class<?> clazz = transformToClass(metadata.getClassName());
        return clazz != null && clazz.isAnnotationPresent(c);
    }

    public Class<?> transformToClass(String className) {
        Class<?> clazz = null;
        try {
            clazz = ClassUtils.forName(className, this.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            logger.info("未找到指定类", className);
        }
        return clazz;
    }

    private void validateCandidates(String basePackages, boolean empty) {
        if (empty) {
            logger.info("扫描指定包下，未发现符合条件的类", basePackages);
        }
    }

    private String getPackageSearchPath(String basePackage) {
        return ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                convertPath(basePackage) + '/' + DEFAULT_RESOURCE_PATTERN;
    }
}

使用

//获取使用指定注解的所有类
List<Class<?>> candidates = AnnotationUtils.getInstance().getClassCandidates("com.cason", PermitAccountStatus.class);
//获取使用指定注解的所有方法
List<Method> methodCandidates = AnnotationUtils.getInstance().getMethodCandidates("com.cason", PermitAccountStatus.class);
//获取使用指定注解的所有字段
List<Field> fieldCandidates = AnnotationUtils.getInstance().getFieldCandidates("com.cason", PermitAccountStatus.class);