JAVA 注解搜索工具类与注解原理讲解（获取方法和类上所有的某个注解，父类继承的注解也支持获取）

基于Spring的AnnotatedElementUtils工具,支持从当前类、父类、接口搜索（支持限制最大深度），支持传入搜索配置、启用缓存。

代码

import cn.hutool.core.collection.CollectionUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;
import org.springframework.core.annotation.AnnotatedElementUtils;

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Executable;
import java.lang.reflect.Member;
import java.lang.reflect.Parameter;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author chenfuxing
 * date: 2024/6/19
 * description: 注解工具类
 **/
public class AnnotationUtil extends AnnotatedElementUtils {
    /**
     * 默认注解搜索配置
     */
    private static final AnnotationSearchConfig DEFAULT_SEARCH_CONFIG = new AnnotationSearchConfig();
    /**
     * 缓存
     */
    private static final Map<String, Set<? extends Annotation>> CACHE = new ConcurrentHashMap<>();

    /**
     * 注解搜索配置
     */
    @Data
    @Accessors(chain = true)
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public static class AnnotationSearchConfig {
        /**
         * 从类上搜索注解
         */
        private boolean searchFromClass = true;
        /**
         * 从父类上搜索注解
         */
        private boolean searchSuperClass = true;
        /**
         * 从父类上搜索注解的最大深度
         */
        private int searchSuperMaxDepth = 3;
        /**
         * 从类的接口上搜索注解
         */
        private boolean searchFromInterfaces = true;
        /**
         * 允许使用缓存
         */
        private boolean enableCache = true;
    }

    /**
     * 获取缓存key
     *
     * @param element
     * @param annotationType
     * @param config
     * @return
     */
    public static String getCacheKey(AnnotatedElement element, Class<?> annotationType, AnnotationSearchConfig config) {
        StringBuilder sb = new StringBuilder();
        sb.append(element != null ? element.toString() : "null");
        sb.append("-");
        sb.append(annotationType != null ? annotationType.getName() : "null");
        sb.append("-");
        sb.append(config != null ? config.toString() : "null");
        return sb.toString();
    }

    /**
     * 获取注解
     * 若有多个则只会返回第一个注解（方法上的优先于类上的）
     *
     * @param element
     * @param annotationType
     * @param <A>
     * @return
     */
    public static <A extends Annotation> A getAnnotation(AnnotatedElement element, Class<A> annotationType) {
        Set<A> allAnnotations = getAllAnnotations(element, annotationType);
        return CollectionUtil.isEmpty(allAnnotations) ? null : allAnnotations.iterator().next();
    }

    /**
     * 获取注解
     * 若有多个则只会返回第一个注解（方法上的优先于类上的）
     *
     * @param element
     * @param annotationType
     * @param <A>
     * @return
     */
    public static <A extends Annotation> A getAnnotation(AnnotatedElement element, Class<A> annotationType, AnnotationSearchConfig config) {
        Set<A> allAnnotations = getAllAnnotations(element, annotationType, config);
        return CollectionUtil.isEmpty(allAnnotations) ? null : allAnnotations.iterator().next();
    }

    /**
     * 获取方法和类上的注解
     *
     * @param element
     * @return
     */
    public static <A extends Annotation> Set<A> getAllAnnotations(AnnotatedElement element, Class<A> annotationType) {
        return getAllAnnotations(element, annotationType, DEFAULT_SEARCH_CONFIG);
    }

    /**
     * 获取方法和类上的注解
     *
     * @param element
     * @return
     */
    public static <A extends Annotation> Set<A> getAllAnnotations(AnnotatedElement element, Class<A> annotationType, AnnotationSearchConfig config) {
        if (config == null) {
            throw new NullPointerException("config can not be null");
        }
        if (config.isEnableCache()) {
            return (Set<A>) CACHE.computeIfAbsent(getCacheKey(element, annotationType, config), k -> getAllAnnotations(element, annotationType, config.getSearchSuperMaxDepth(), config));
        }
        return getAllAnnotations(element, annotationType, config.getSearchSuperMaxDepth(), config);
    }

    /**
     * 获取方法和类上的注解
     *
     * @param element
     * @return
     */
    private static <A extends Annotation> Set<A> getAllAnnotations(AnnotatedElement element, Class<A> annotationType, int depth, AnnotationSearchConfig config) {
        if (element == null || annotationType == null || depth <= 0 || config == null) {
            return Collections.emptySet();
        }
        boolean isClass = element instanceof Class;
        Class<?> declaringClass = isClass ? (Class<?>) element : element.getClass();
        if (element instanceof Executable) {
            declaringClass = ((Executable) element).getDeclaringClass();
        }
        if (element instanceof Member) {
            declaringClass = ((Member) element).getDeclaringClass();
        }
        if (element instanceof Parameter) {
            declaringClass = ((Parameter) element).getDeclaringExecutable().getDeclaringClass();
        }
        Class<?>[] interfaces = declaringClass.getInterfaces();
        Class<?> superclass = declaringClass.getSuperclass();

        // 自身的注解
        Set<A> methodAnnotationSet = isClass ? Collections.emptySet() : getAllMergedAnnotations(element, annotationType);
        // 类上的注解
        Set<A> classAnnotationSet = config.isSearchFromClass() ? getAllMergedAnnotations(declaringClass, annotationType) : Collections.emptySet();
        // 接口上的注解
        Set<A> interfaceAnnotationSet = config.isSearchFromInterfaces() ? (interfaces.length > 0 ? Arrays.stream(interfaces).map(interfaceCls -> getAllMergedAnnotations(interfaceCls, annotationType)).flatMap(Set::stream).collect(Collectors.toSet()) : Collections.emptySet()) : Collections.emptySet();
        // 父类上的注解
        Set<A> superClassAnnotationSet = config.isSearchSuperClass() ? (!Object.class.equals(superclass) ? getAllAnnotations(superclass, annotationType, depth - 1, config) : Collections.emptySet()) : Collections.emptySet();

        return Stream.of(methodAnnotationSet, classAnnotationSet, interfaceAnnotationSet, superClassAnnotationSet).flatMap(Set::stream).collect(Collectors.toSet());
    }
}

测试

定义了一个类，检查登录类型，用于限制某些端的用户只能访问某些端自己的接口

额外定义了多个快捷注解，快捷注解上标注了@CheckLoginType，预设了值。

方法上加注解，类上不加

调试结果

类上加注解、方法上加注解

运行调试

都能正常获取到方法、类上该注解（包括继承来的）

注解原理

注解基类Annotation，注释里写了从1.5版本引入的，所有的注解都会继承这个类，且不需要在定义的时候标明继承自这个类，只提供了annotationType来返回这个注解的Class，以及每个对象都有的equals、hashcode、toString()方法，那我们平时经常用的getAnnotation、isAnnotationPresent这些方法是哪里定义的呢？

我们通过方法找到接口为AnnotationElement，可以看到我们平时反射获取注解时的方法是定义在这个接口里的。

我们再看这个接口有哪些实现类，可以看到我们平时常用的类、方法、参数、构造方法等都实现了这个接口，因此这些地方都是可以加注解并通过反射拿到加了的注解的。

那我们看下在方法上获取注解时底层是怎么实现的，打开Method对象，可以看到它是调了父类的实现，继续往父类看

父类是Executable类

这个类是一个抽象类，上门写了是提供一些Method类和Constructor类公共使用的方法，它是一个共享的父类。

declaredAnnotations()的实现是，当前类有声明注解则直接返回当前类的declaredAnnotations这个Map，而这个map是记录的当前这个Method对象定义的一些注解，若有则直接返回这个，没有的话就会看有没有root，有root则返回root声明的所有注解的map。

而这个root对象，只有在执行Method.copy的时候才会有，那你可以当做root一直是个null的

因此平时你利用反射获取method的注解时其实就只获取到了这个方法上直接声明的注解，类上的，当前方法注解里继承的注解都不会返回的。这就是JDK方式的实现，因此spring在实现的时候提供了工具类去解决这个问题

性能测试

执行10000次，总耗时：240ms，平均耗时：0.024ms