org.springframework.core.annotation

## 类 AnnotationUtils

- java.lang.Object
- - org.springframework.core.annotation.AnnotationUtils

-     public abstract class AnnotationUtils
      extends Object

  General utility methods for working with annotations, handling meta-annotations, bridge methods (which the compiler generates for generic declarations) as well as super methods (for optional annotation inheritance).

  Note that most of the features of this class are not provided by the JDK's introspection facilities themselves.

  As a general rule for runtime-retained application annotations (e.g. for transaction control, authorization, or service exposure), always use the lookup methods on this class (e.g. `findAnnotation(Method, Class)` or `getAnnotation(Method, Class)`) instead of the plain annotation lookup methods in the JDK. You can still explicitly choose between a get lookup on the given class level only (`getAnnotation(Method, Class)`) and a find lookup in the entire inheritance hierarchy of the given method (`findAnnotation(Method, Class)`).

  ### Terminology

  The terms directly present, indirectly present, and present have the same meanings as defined in the class-level javadoc for `AnnotatedElement` (in Java 8).

  An annotation is meta-present on an element if the annotation is declared as a meta-annotation on some other annotation which is present on the element. Annotation `A` is meta-present on another annotation if `A` is either directly present or meta-present on the other annotation.

  ### Meta-annotation Support

  Most `find*()` methods and some `get*()` methods in this class provide support for finding annotations used as meta-annotations. Consult the javadoc for each method in this class for details. For fine-grained support for meta-annotations with attribute overrides in composed annotations, consider using `AnnotatedElementUtils`'s more specific methods instead.

  ### Attribute Aliases

  All public methods in this class that return annotations, arrays of annotations, or `AnnotationAttributes` transparently support attribute aliases configured via `@AliasFor`. Consult the various `synthesizeAnnotation*(..)` methods for details.

  ### Search Scope

  The search algorithms used by methods in this class stop searching for an annotation once the first annotation of the specified type has been found. As a consequence, additional annotations of the specified type will be silently ignored.

  从以下版本开始:
    2.0
  作者:
    Rob Harrop, Juergen Hoeller, Sam Brannen, Mark Fisher, Chris Beams, Phillip Webb, Oleg Zhurakousky
  另请参阅:
    `AliasFor`, `AnnotationAttributes`, `AnnotatedElementUtils`, `BridgeMethodResolver`, `AnnotatedElement.getAnnotations()`, `AnnotatedElement.getAnnotation(Class)`, `AnnotatedElement.getDeclaredAnnotations()`

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `static String` | `VALUE` The attribute name for annotations with a single element.

  - ### 构造器概要

    构造器
    构造器和说明
    `AnnotationUtils()`

  - ### 方法概要

    所有方法 静态方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `static void` | `clearCache()` Clear the internal annotation metadata cache.
    `static <A extends Annotation> A` | `findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)` Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
    `static <A extends Annotation> A` | `findAnnotation(Class<?> clazz, Class<A> annotationType)` Find a single `Annotation` of `annotationType` on the supplied `Class`, traversing its interfaces, annotations, and superclasses if the annotation is not directly present on the given class itself.
    `static <A extends Annotation> A` | `findAnnotation(Method method, Class<A> annotationType)` Find a single `Annotation` of `annotationType` on the supplied `Method`, traversing its super methods (i.e. from superclasses and interfaces) if the annotation is not directly present on the given method itself.
    `static Class<?>` | `findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)` Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which an annotation of the specified `annotationType` is directly present.
    `static Class<?>` | `findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)` Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which at least one of the specified `annotationTypes` is directly present.
    `static <A extends Annotation> A` | `getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied `AnnotatedElement`, where the annotation is either present or meta-present on the `AnnotatedElement`.
    `static <A extends Annotation> A` | `getAnnotation(Annotation annotation, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied annotation: either the given annotation itself or a direct meta-annotation thereof.
    `static <A extends Annotation> A` | `getAnnotation(Method method, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied `Method`, where the annotation is either present or meta-present on the method.
    `static AnnotationAttributes` | `getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation)` Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
    `static AnnotationAttributes` | `getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
    `static Map<String,Object>` | `getAnnotationAttributes(Annotation annotation)` Retrieve the given annotation's attributes as a `Map`, preserving all attribute types.
    `static Map<String,Object>` | `getAnnotationAttributes(Annotation annotation, boolean classValuesAsString)` Retrieve the given annotation's attributes as a `Map`.
    `static AnnotationAttributes` | `getAnnotationAttributes(Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
    `static Annotation[]` | `getAnnotations(AnnotatedElement annotatedElement)` Get all `Annotations` that are present on the supplied `AnnotatedElement`.
    `static Annotation[]` | `getAnnotations(Method method)` Get all `Annotations` that are present on the supplied `Method`.
    `static <A extends Annotation> Set<A>` | `getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType)` Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.
    `static <A extends Annotation> Set<A>` | `getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)` Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.
    `static Object` | `getDefaultValue(Annotation annotation)` Retrieve the default value of the `value` attribute of a single-element Annotation, given an annotation instance.
    `static Object` | `getDefaultValue(Annotation annotation, String attributeName)` Retrieve the default value of a named attribute, given an annotation instance.
    `static Object` | `getDefaultValue(Class<? extends Annotation> annotationType)` Retrieve the default value of the `value` attribute of a single-element Annotation, given the `annotation type`.
    `static Object` | `getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)` Retrieve the default value of a named attribute, given the `annotation type`.
    `static <A extends Annotation> Set<A>` | `getRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType)` Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.
    `static <A extends Annotation> Set<A>` | `getRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)` Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.
    `static Object` | `getValue(Annotation annotation)` Retrieve the value of the `value` attribute of a single-element Annotation, given an annotation instance.
    `static Object` | `getValue(Annotation annotation, String attributeName)` Retrieve the value of a named attribute, given an annotation instance.
    `static boolean` | `isAnnotationDeclaredLocally(Class<? extends Annotation> annotationType, Class<?> clazz)` Determine whether an annotation of the specified `annotationType` is declared locally (i.e.
    `static boolean` | `isAnnotationInherited(Class<? extends Annotation> annotationType, Class<?> clazz)` Determine whether an annotation of the specified `annotationType` is present on the supplied `clazz` and is inherited (i.e. not directly present).
    `static boolean` | `isAnnotationMetaPresent(Class<? extends Annotation> annotationType, Class<? extends Annotation> metaAnnotationType)` Determine if an annotation of type `metaAnnotationType` is meta-present on the supplied `annotationType`.
    `static boolean` | `isInJavaLangAnnotationPackage(Annotation annotation)` Determine if the supplied `Annotation` is defined in the core JDK `java.lang.annotation` package.
    `static boolean` | `isInJavaLangAnnotationPackage(String annotationType)` Determine if the `Annotation` with the supplied name is defined in the core JDK `java.lang.annotation` package.
    `static void` | `postProcessAnnotationAttributes(Object annotatedElement, AnnotationAttributes attributes, boolean classValuesAsString)` Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.
    `static void` | `registerDefaultValues(AnnotationAttributes attributes)` Register the annotation-declared default values for the given attributes, if available.
    `static <A extends Annotation> A` | `synthesizeAnnotation(A annotation, AnnotatedElement annotatedElement)` Synthesize an annotation from the supplied `annotation` by wrapping it in a dynamic proxy that transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
    `static <A extends Annotation> A` | `synthesizeAnnotation(Class<A> annotationType)` Synthesize an annotation from its default attributes values.
    `static <A extends Annotation> A` | `synthesizeAnnotation(Map<String,Object> attributes, Class<A> annotationType, AnnotatedElement annotatedElement)` Synthesize an annotation from the supplied map of annotation attributes by wrapping the map in a dynamic proxy that implements an annotation of the specified `annotationType` and transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
    `static void` | `validateAnnotation(Annotation annotation)` Check the declared attributes of the given annotation, in particular covering Google App Engine's late arrival of `TypeNotPresentExceptionProxy` for `Class` values (instead of early `Class.getAnnotations() failure`.

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 字段详细资料

    - #### VALUE

          public static final String VALUE

      The attribute name for annotations with a single element.
      另请参阅:
        常量字段值

  - ### 构造器详细资料

    - #### AnnotationUtils

          public AnnotationUtils()

  - ### 方法详细资料

    - #### getAnnotation

          @Nullable
          public static <A extends Annotation> A getAnnotation(Annotation annotation,
                                                                          Class<A> annotationType)

      Get a single `Annotation` of `annotationType` from the supplied annotation: either the given annotation itself or a direct meta-annotation thereof.

      Note that this method supports only a single level of meta-annotations. For support for arbitrary levels of meta-annotations, use one of the `find*()` methods instead.

      参数:
        `annotation` - the Annotation to check
        `annotationType` - the annotation type to look for, both locally and as a meta-annotation
      返回:
        the first matching annotation, or `null` if not found
      从以下版本开始:
        4.0

    - #### getAnnotation

          @Nullable
          public static <A extends Annotation> A getAnnotation(AnnotatedElement annotatedElement,
                                                                          Class<A> annotationType)

      Get a single `Annotation` of `annotationType` from the supplied `AnnotatedElement`, where the annotation is either present or meta-present on the `AnnotatedElement`.

      Note that this method supports only a single level of meta-annotations. For support for arbitrary levels of meta-annotations, use `findAnnotation(AnnotatedElement, Class)` instead.

      参数:
        `annotatedElement` - the `AnnotatedElement` from which to get the annotation
        `annotationType` - the annotation type to look for, both locally and as a meta-annotation
      返回:
        the first matching annotation, or `null` if not found
      从以下版本开始:
        3.1

    - #### getAnnotation

          @Nullable
          public static <A extends Annotation> A getAnnotation(Method method,
                                                                          Class<A> annotationType)

      Get a single `Annotation` of `annotationType` from the supplied `Method`, where the annotation is either present or meta-present on the method.

      Correctly handles bridge `Methods` generated by the compiler.

      Note that this method supports only a single level of meta-annotations. For support for arbitrary levels of meta-annotations, use `findAnnotation(Method, Class)` instead.

      参数:
        `method` - the method to look for annotations on
        `annotationType` - the annotation type to look for
      返回:
        the first matching annotation, or `null` if not found
      另请参阅:
        `BridgeMethodResolver.findBridgedMethod(Method)`, `getAnnotation(AnnotatedElement, Class)`

    - #### getAnnotations

          @Nullable
          public static Annotation[] getAnnotations(AnnotatedElement annotatedElement)

      Get all `Annotations` that are present on the supplied `AnnotatedElement`.

      Meta-annotations will not be searched.

      参数:
        `annotatedElement` - the Method, Constructor or Field to retrieve annotations from
      返回:
        the annotations found, an empty array, or `null` if not resolvable (e.g. because nested Class values in annotation attributes failed to resolve at runtime)
      从以下版本开始:
        4.0.8
      另请参阅:
        `AnnotatedElement.getAnnotations()`

    - #### getAnnotations

          @Nullable
          public static Annotation[] getAnnotations(Method method)

      Get all `Annotations` that are present on the supplied `Method`.

      Correctly handles bridge `Methods` generated by the compiler.

      Meta-annotations will not be searched.

      参数:
        `method` - the Method to retrieve annotations from
      返回:
        the annotations found, an empty array, or `null` if not resolvable (e.g. because nested Class values in annotation attributes failed to resolve at runtime)
      另请参阅:
        `BridgeMethodResolver.findBridgedMethod(Method)`, `AnnotatedElement.getAnnotations()`

    - #### getRepeatableAnnotations

          public static <A extends Annotation> Set<A> getRepeatableAnnotations(AnnotatedElement annotatedElement,
                                                                               Class<A> annotationType)

      Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.

      This method mimics the functionality of Java 8's `AnnotatedElement.getAnnotationsByType(Class)` with support for automatic detection of a container annotation declared via @`Repeatable` (when running on Java 8 or higher) and with additional support for meta-annotations.

      Handles both single annotations and annotations nested within a container annotation.

      Correctly handles bridge methods generated by the compiler if the supplied element is a `Method`.

      Meta-annotations will be searched if the annotation is not present on the supplied element.

      参数:
        `annotatedElement` - the element to look for annotations on
        `annotationType` - the annotation type to look for
      返回:
        the annotations found or an empty set (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getRepeatableAnnotations(AnnotatedElement, Class, Class)`, `getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class)`, `AnnotatedElementUtils.getMergedRepeatableAnnotations(AnnotatedElement, Class)`, `BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method)`, `Repeatable`, `AnnotatedElement.getAnnotationsByType(java.lang.Class<T>)`

    - #### getRepeatableAnnotations

          public static <A extends Annotation> Set<A> getRepeatableAnnotations(AnnotatedElement annotatedElement,
                                                                               Class<A> annotationType,
                                                                               @Nullable
                                                                               Class<? extends Annotation> containerAnnotationType)

      Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.

      This method mimics the functionality of Java 8's `AnnotatedElement.getAnnotationsByType(Class)` with additional support for meta-annotations.

      Handles both single annotations and annotations nested within a container annotation.

      Correctly handles bridge methods generated by the compiler if the supplied element is a `Method`.

      Meta-annotations will be searched if the annotation is not present on the supplied element.

      参数:
        `annotatedElement` - the element to look for annotations on
        `annotationType` - the annotation type to look for
        `containerAnnotationType` - the type of the container that holds the annotations; may be `null` if a container is not supported or if it should be looked up via @`Repeatable` when running on Java 8 or higher
      返回:
        the annotations found or an empty set (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getRepeatableAnnotations(AnnotatedElement, Class)`, `getDeclaredRepeatableAnnotations(AnnotatedElement, Class)`, `getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class)`, `AnnotatedElementUtils.getMergedRepeatableAnnotations(AnnotatedElement, Class, Class)`, `BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method)`, `Repeatable`, `AnnotatedElement.getAnnotationsByType(java.lang.Class<T>)`

    - #### getDeclaredRepeatableAnnotations

          public static <A extends Annotation> Set<A> getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement,
                                                                                       Class<A> annotationType)

      Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.

      This method mimics the functionality of Java 8's `AnnotatedElement.getDeclaredAnnotationsByType(Class)` with support for automatic detection of a container annotation declared via @`Repeatable` (when running on Java 8 or higher) and with additional support for meta-annotations.

      Handles both single annotations and annotations nested within a container annotation.

      Correctly handles bridge methods generated by the compiler if the supplied element is a `Method`.

      Meta-annotations will be searched if the annotation is not present on the supplied element.

      参数:
        `annotatedElement` - the element to look for annotations on
        `annotationType` - the annotation type to look for
      返回:
        the annotations found or an empty set (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getRepeatableAnnotations(AnnotatedElement, Class)`, `getRepeatableAnnotations(AnnotatedElement, Class, Class)`, `getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class)`, `AnnotatedElementUtils.getMergedRepeatableAnnotations(AnnotatedElement, Class)`, `BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method)`, `Repeatable`, `AnnotatedElement.getDeclaredAnnotationsByType(java.lang.Class<T>)`

    - #### getDeclaredRepeatableAnnotations

          public static <A extends Annotation> Set<A> getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement,
                                                                                       Class<A> annotationType,
                                                                                       @Nullable
                                                                                       Class<? extends Annotation> containerAnnotationType)

      Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.

      This method mimics the functionality of Java 8's `AnnotatedElement.getDeclaredAnnotationsByType(Class)` with additional support for meta-annotations.

      Handles both single annotations and annotations nested within a container annotation.

      Correctly handles bridge methods generated by the compiler if the supplied element is a `Method`.

      Meta-annotations will be searched if the annotation is not present on the supplied element.

      参数:
        `annotatedElement` - the element to look for annotations on
        `annotationType` - the annotation type to look for
        `containerAnnotationType` - the type of the container that holds the annotations; may be `null` if a container is not supported or if it should be looked up via @`Repeatable` when running on Java 8 or higher
      返回:
        the annotations found or an empty set (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getRepeatableAnnotations(AnnotatedElement, Class)`, `getRepeatableAnnotations(AnnotatedElement, Class, Class)`, `getDeclaredRepeatableAnnotations(AnnotatedElement, Class)`, `AnnotatedElementUtils.getMergedRepeatableAnnotations(AnnotatedElement, Class, Class)`, `BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method)`, `Repeatable`, `AnnotatedElement.getDeclaredAnnotationsByType(java.lang.Class<T>)`

    - #### findAnnotation

          @Nullable
          public static <A extends Annotation> A findAnnotation(AnnotatedElement annotatedElement,
                                                                           @Nullable
                                                                           Class<A> annotationType)

      Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.

      Meta-annotations will be searched if the annotation is not directly present on the supplied element.

      Warning: this method operates generically on annotated elements. In other words, this method does not execute specialized search algorithms for classes or methods. If you require the more specific semantics of `findAnnotation(Class, Class)` or `findAnnotation(Method, Class)`, invoke one of those methods instead.

      参数:
        `annotatedElement` - the `AnnotatedElement` on which to find the annotation
        `annotationType` - the annotation type to look for, both locally and as a meta-annotation
      返回:
        the first matching annotation, or `null` if not found
      从以下版本开始:
        4.2

    - #### findAnnotation

          @Nullable
          public static <A extends Annotation> A findAnnotation(Method method,
                                                                           @Nullable
                                                                           Class<A> annotationType)

      Find a single `Annotation` of `annotationType` on the supplied `Method`, traversing its super methods (i.e. from superclasses and interfaces) if the annotation is not directly present on the given method itself.

      Correctly handles bridge `Methods` generated by the compiler.

      Meta-annotations will be searched if the annotation is not directly present on the method.

      Annotations on methods are not inherited by default, so we need to handle this explicitly.

      参数:
        `method` - the method to look for annotations on
        `annotationType` - the annotation type to look for
      返回:
        the first matching annotation, or `null` if not found
      另请参阅:
        `getAnnotation(Method, Class)`

    - #### findAnnotation

          @Nullable
          public static <A extends Annotation> A findAnnotation(Class<?> clazz,
                                                                           @Nullable
                                                                           Class<A> annotationType)

      Find a single `Annotation` of `annotationType` on the supplied `Class`, traversing its interfaces, annotations, and superclasses if the annotation is not directly present on the given class itself.

      This method explicitly handles class-level annotations which are not declared as `inherited` as well as meta-annotations and annotations on interfaces.

      The algorithm operates as follows:

      1. Search for the annotation on the given class and return it if found.
      2. Recursively search through all annotations that the given class declares.
      3. Recursively search through all interfaces that the given class declares.
      4. Recursively search through the superclass hierarchy of the given class.

      Note: in this context, the term recursively means that the search process continues by returning to step #1 with the current interface, annotation, or superclass as the class to look for annotations on.

      参数:
        `clazz` - the class to look for annotations on
        `annotationType` - the type of annotation to look for
      返回:
        the first matching annotation, or `null` if not found

    - #### findAnnotationDeclaringClass

          @Nullable
          public static Class<?> findAnnotationDeclaringClass(Class<? extends Annotation> annotationType,
                                                                         @Nullable
                                                                         Class<?> clazz)

      Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which an annotation of the specified `annotationType` is directly present.

      If the supplied `clazz` is an interface, only the interface itself will be checked; the inheritance hierarchy for interfaces will not be traversed.

      Meta-annotations will not be searched.

      The standard `Class` API does not provide a mechanism for determining which class in an inheritance hierarchy actually declares an `Annotation`, so we need to handle this explicitly.

      参数:
        `annotationType` - the annotation type to look for
        `clazz` - the class to check for the annotation on (may be `null`)
      返回:
        the first `Class` in the inheritance hierarchy that declares an annotation of the specified `annotationType`, or `null` if not found
      另请参阅:
        `Class.isAnnotationPresent(Class)`, `Class.getDeclaredAnnotations()`, `findAnnotationDeclaringClassForTypes(List, Class)`, `isAnnotationDeclaredLocally(Class, Class)`

    - #### findAnnotationDeclaringClassForTypes

          @Nullable
          public static Class<?> findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes,
                                                                                 @Nullable
                                                                                 Class<?> clazz)

      Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which at least one of the specified `annotationTypes` is directly present.

      If the supplied `clazz` is an interface, only the interface itself will be checked; the inheritance hierarchy for interfaces will not be traversed.

      Meta-annotations will not be searched.

      The standard `Class` API does not provide a mechanism for determining which class in an inheritance hierarchy actually declares one of several candidate annotations, so we need to handle this explicitly.

      参数:
        `annotationTypes` - the annotation types to look for
        `clazz` - the class to check for the annotation on (may be `null`)
      返回:
        the first `Class` in the inheritance hierarchy that declares an annotation of at least one of the specified `annotationTypes`, or `null` if not found
      从以下版本开始:
        3.2.2
      另请参阅:
        `Class.isAnnotationPresent(Class)`, `Class.getDeclaredAnnotations()`, `findAnnotationDeclaringClass(Class, Class)`, `isAnnotationDeclaredLocally(Class, Class)`

    - #### isAnnotationDeclaredLocally

          public static boolean isAnnotationDeclaredLocally(Class<? extends Annotation> annotationType,
                                                            Class<?> clazz)

      Determine whether an annotation of the specified `annotationType` is declared locally (i.e. directly present) on the supplied `clazz`.

      The supplied `Class` may represent any type.

      Meta-annotations will not be searched.

      Note: This method does not determine if the annotation is inherited. For greater clarity regarding inherited annotations, consider using `isAnnotationInherited(Class, Class)` instead.

      参数:
        `annotationType` - the annotation type to look for
        `clazz` - the class to check for the annotation on
      返回:
        `true` if an annotation of the specified `annotationType` is directly present
      另请参阅:
        `Class.getDeclaredAnnotations()`, `Class.getDeclaredAnnotation(Class)`, `isAnnotationInherited(Class, Class)`

    - #### isAnnotationInherited

          public static boolean isAnnotationInherited(Class<? extends Annotation> annotationType,
                                                      Class<?> clazz)

      Determine whether an annotation of the specified `annotationType` is present on the supplied `clazz` and is inherited (i.e. not directly present).

      Meta-annotations will not be searched.

      If the supplied `clazz` is an interface, only the interface itself will be checked. In accordance with standard meta-annotation semantics in Java, the inheritance hierarchy for interfaces will not be traversed. See the javadoc for the `@Inherited` meta-annotation for further details regarding annotation inheritance.

      参数:
        `annotationType` - the annotation type to look for
        `clazz` - the class to check for the annotation on
      返回:
        `true` if an annotation of the specified `annotationType` is present and inherited
      另请参阅:
        `Class.isAnnotationPresent(Class)`, `isAnnotationDeclaredLocally(Class, Class)`

    - #### isAnnotationMetaPresent

          public static boolean isAnnotationMetaPresent(Class<? extends Annotation> annotationType,
                                                        @Nullable
                                                        Class<? extends Annotation> metaAnnotationType)

      Determine if an annotation of type `metaAnnotationType` is meta-present on the supplied `annotationType`.
      参数:
        `annotationType` - the annotation type to search on
        `metaAnnotationType` - the type of meta-annotation to search for
      返回:
        `true` if such an annotation is meta-present
      从以下版本开始:
        4.2.1

    - #### isInJavaLangAnnotationPackage

          public static boolean isInJavaLangAnnotationPackage(@Nullable
                                                              Annotation annotation)

      Determine if the supplied `Annotation` is defined in the core JDK `java.lang.annotation` package.
      参数:
        `annotation` - the annotation to check
      返回:
        `true` if the annotation is in the `java.lang.annotation` package

    - #### isInJavaLangAnnotationPackage

          public static boolean isInJavaLangAnnotationPackage(@Nullable
                                                              String annotationType)

      Determine if the `Annotation` with the supplied name is defined in the core JDK `java.lang.annotation` package.
      参数:
        `annotationType` - the name of the annotation type to check
      返回:
        `true` if the annotation is in the `java.lang.annotation` package
      从以下版本开始:
        4.2

    - #### validateAnnotation

          public static void validateAnnotation(Annotation annotation)

      Check the declared attributes of the given annotation, in particular covering Google App Engine's late arrival of `TypeNotPresentExceptionProxy` for `Class` values (instead of early `Class.getAnnotations() failure`.

      This method not failing indicates that `getAnnotationAttributes(Annotation)` won't failure either (when attempted later on).

      参数:
        `annotation` - the annotation to validate
      抛出:
        `IllegalStateException` - if a declared `Class` attribute could not be read
      从以下版本开始:
        4.3.15
      另请参阅:
        `Class.getAnnotations()`, `getAnnotationAttributes(Annotation)`

    - #### getAnnotationAttributes

          public static Map<String,Object> getAnnotationAttributes(Annotation annotation)

      Retrieve the given annotation's attributes as a `Map`, preserving all attribute types.

      Equivalent to calling `getAnnotationAttributes(Annotation, boolean, boolean)` with the `classValuesAsString` and `nestedAnnotationsAsMap` parameters set to `false`.

      Note: This method actually returns an `AnnotationAttributes` instance. However, the `Map` signature has been preserved for binary compatibility.

      参数:
        `annotation` - the annotation to retrieve the attributes for
      返回:
        the Map of annotation attributes, with attribute names as keys and corresponding attribute values as values (never `null`)
      另请参阅:
        `getAnnotationAttributes(AnnotatedElement, Annotation)`, `getAnnotationAttributes(Annotation, boolean, boolean)`, `getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)`

    - #### getAnnotationAttributes

          public static Map<String,Object> getAnnotationAttributes(Annotation annotation,
                                                                   boolean classValuesAsString)

      Retrieve the given annotation's attributes as a `Map`.

      Equivalent to calling `getAnnotationAttributes(Annotation, boolean, boolean)` with the `nestedAnnotationsAsMap` parameter set to `false`.

      Note: This method actually returns an `AnnotationAttributes` instance. However, the `Map` signature has been preserved for binary compatibility.

      参数:
        `annotation` - the annotation to retrieve the attributes for
        `classValuesAsString` - whether to convert Class references into Strings (for compatibility with `AnnotationMetadata`) or to preserve them as Class references
      返回:
        the Map of annotation attributes, with attribute names as keys and corresponding attribute values as values (never `null`)
      另请参阅:
        `getAnnotationAttributes(Annotation, boolean, boolean)`

    - #### getAnnotationAttributes

          public static AnnotationAttributes getAnnotationAttributes(Annotation annotation,
                                                                     boolean classValuesAsString,
                                                                     boolean nestedAnnotationsAsMap)

      Retrieve the given annotation's attributes as an `AnnotationAttributes` map.

      This method provides fully recursive annotation reading capabilities on par with the reflection-based `StandardAnnotationMetadata`.

      参数:
        `annotation` - the annotation to retrieve the attributes for
        `classValuesAsString` - whether to convert Class references into Strings (for compatibility with `AnnotationMetadata`) or to preserve them as Class references
        `nestedAnnotationsAsMap` - whether to convert nested annotations into `AnnotationAttributes` maps (for compatibility with `AnnotationMetadata`) or to preserve them as `Annotation` instances
      返回:
        the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values (never `null`)
      从以下版本开始:
        3.1.1

    - #### getAnnotationAttributes

          public static AnnotationAttributes getAnnotationAttributes(@Nullable
                                                                     AnnotatedElement annotatedElement,
                                                                     Annotation annotation)

      Retrieve the given annotation's attributes as an `AnnotationAttributes` map.

      Equivalent to calling `getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)` with the `classValuesAsString` and `nestedAnnotationsAsMap` parameters set to `false`.

      参数:
        `annotatedElement` - the element that is annotated with the supplied annotation; may be `null` if unknown
        `annotation` - the annotation to retrieve the attributes for
      返回:
        the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)`

    - #### getAnnotationAttributes

          public static AnnotationAttributes getAnnotationAttributes(@Nullable
                                                                     AnnotatedElement annotatedElement,
                                                                     Annotation annotation,
                                                                     boolean classValuesAsString,
                                                                     boolean nestedAnnotationsAsMap)

      Retrieve the given annotation's attributes as an `AnnotationAttributes` map.

      This method provides fully recursive annotation reading capabilities on par with the reflection-based `StandardAnnotationMetadata`.

      参数:
        `annotatedElement` - the element that is annotated with the supplied annotation; may be `null` if unknown
        `annotation` - the annotation to retrieve the attributes for
        `classValuesAsString` - whether to convert Class references into Strings (for compatibility with `AnnotationMetadata`) or to preserve them as Class references
        `nestedAnnotationsAsMap` - whether to convert nested annotations into `AnnotationAttributes` maps (for compatibility with `AnnotationMetadata`) or to preserve them as `Annotation` instances
      返回:
        the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values (never `null`)
      从以下版本开始:
        4.2

    - #### registerDefaultValues

          public static void registerDefaultValues(AnnotationAttributes attributes)

      Register the annotation-declared default values for the given attributes, if available.
      参数:
        `attributes` - the annotation attributes to process
      从以下版本开始:
        4.3.2

    - #### postProcessAnnotationAttributes

          public static void postProcessAnnotationAttributes(@Nullable
                                                             Object annotatedElement,
                                                             AnnotationAttributes attributes,
                                                             boolean classValuesAsString)

      Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.

      Specifically, this method enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor` and replaces default value placeholders with their original default values.

      参数:
        `annotatedElement` - the element that is annotated with an annotation or annotation hierarchy from which the supplied attributes were created; may be `null` if unknown
        `attributes` - the annotation attributes to post-process
        `classValuesAsString` - whether to convert Class references into Strings (for compatibility with `AnnotationMetadata`) or to preserve them as Class references
      从以下版本开始:
        4.3.2
      另请参阅:
        `postProcessAnnotationAttributes(Object, AnnotationAttributes, boolean, boolean)`, `getDefaultValue(Class, String)`

    - #### getValue

          @Nullable
          public static Object getValue(Annotation annotation)

      Retrieve the value of the `value` attribute of a single-element Annotation, given an annotation instance.
      参数:
        `annotation` - the annotation instance from which to retrieve the value
      返回:
        the attribute value, or `null` if not found unless the attribute value cannot be retrieved due to an `AnnotationConfigurationException`, in which case such an exception will be rethrown
      另请参阅:
        `getValue(Annotation, String)`

    - #### getValue

          @Nullable
          public static Object getValue(@Nullable
                                                   Annotation annotation,
                                                   @Nullable
                                                   String attributeName)

      Retrieve the value of a named attribute, given an annotation instance.
      参数:
        `annotation` - the annotation instance from which to retrieve the value
        `attributeName` - the name of the attribute value to retrieve
      返回:
        the attribute value, or `null` if not found unless the attribute value cannot be retrieved due to an `AnnotationConfigurationException`, in which case such an exception will be rethrown
      另请参阅:
        `getValue(Annotation)`, `rethrowAnnotationConfigurationException(Throwable)`

    - #### getDefaultValue

          @Nullable
          public static Object getDefaultValue(Annotation annotation)

      Retrieve the default value of the `value` attribute of a single-element Annotation, given an annotation instance.
      参数:
        `annotation` - the annotation instance from which to retrieve the default value
      返回:
        the default value, or `null` if not found
      另请参阅:
        `getDefaultValue(Annotation, String)`

    - #### getDefaultValue

          @Nullable
          public static Object getDefaultValue(@Nullable
                                                          Annotation annotation,
                                                          @Nullable
                                                          String attributeName)

      Retrieve the default value of a named attribute, given an annotation instance.
      参数:
        `annotation` - the annotation instance from which to retrieve the default value
        `attributeName` - the name of the attribute value to retrieve
      返回:
        the default value of the named attribute, or `null` if not found
      另请参阅:
        `getDefaultValue(Class, String)`

    - #### getDefaultValue

          @Nullable
          public static Object getDefaultValue(Class<? extends Annotation> annotationType)

      Retrieve the default value of the `value` attribute of a single-element Annotation, given the `annotation type`.
      参数:
        `annotationType` - the annotation type for which the default value should be retrieved
      返回:
        the default value, or `null` if not found
      另请参阅:
        `getDefaultValue(Class, String)`

    - #### getDefaultValue

          @Nullable
          public static Object getDefaultValue(@Nullable
                                                          Class<? extends Annotation> annotationType,
                                                          @Nullable
                                                          String attributeName)

      Retrieve the default value of a named attribute, given the `annotation type`.
      参数:
        `annotationType` - the annotation type for which the default value should be retrieved
        `attributeName` - the name of the attribute value to retrieve.
      返回:
        the default value of the named attribute, or `null` if not found
      另请参阅:
        `getDefaultValue(Annotation, String)`

    - #### synthesizeAnnotation

          public static <A extends Annotation> A synthesizeAnnotation(A annotation,
                                                                      @Nullable
                                                                      AnnotatedElement annotatedElement)

      Synthesize an annotation from the supplied `annotation` by wrapping it in a dynamic proxy that transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
      参数:
        `annotation` - the annotation to synthesize
        `annotatedElement` - the element that is annotated with the supplied annotation; may be `null` if unknown
      返回:
        the synthesized annotation if the supplied annotation is synthesizable; `null` if the supplied annotation is `null`; otherwise the supplied annotation unmodified
      抛出:
        `AnnotationConfigurationException` - if invalid configuration of `@AliasFor` is detected
      从以下版本开始:
        4.2
      另请参阅:
        `synthesizeAnnotation(Map, Class, AnnotatedElement)`, `synthesizeAnnotation(Class)`

    - #### synthesizeAnnotation

          public static <A extends Annotation> A synthesizeAnnotation(Map<String,Object> attributes,
                                                                      Class<A> annotationType,
                                                                      @Nullable
                                                                      AnnotatedElement annotatedElement)

      Synthesize an annotation from the supplied map of annotation attributes by wrapping the map in a dynamic proxy that implements an annotation of the specified `annotationType` and transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.

      The supplied map must contain a key-value pair for every attribute defined in the supplied `annotationType` that is not aliased or does not have a default value. Nested maps and nested arrays of maps will be recursively synthesized into nested annotations or nested arrays of annotations, respectively.

      Note that `AnnotationAttributes` is a specialized type of `Map` that is an ideal candidate for this method's `attributes` argument.

      参数:
        `attributes` - the map of annotation attributes to synthesize
        `annotationType` - the type of annotation to synthesize
        `annotatedElement` - the element that is annotated with the annotation corresponding to the supplied attributes; may be `null` if unknown
      返回:
        the synthesized annotation
      抛出:
        `IllegalArgumentException` - if a required attribute is missing or if an attribute is not of the correct type
        `AnnotationConfigurationException` - if invalid configuration of `@AliasFor` is detected
      从以下版本开始:
        4.2
      另请参阅:
        `synthesizeAnnotation(Annotation, AnnotatedElement)`, `synthesizeAnnotation(Class)`, `getAnnotationAttributes(AnnotatedElement, Annotation)`, `getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)`

    - #### synthesizeAnnotation

          public static <A extends Annotation> A synthesizeAnnotation(Class<A> annotationType)

      Synthesize an annotation from its default attributes values.

      This method simply delegates to `synthesizeAnnotation(Map, Class, AnnotatedElement)`, supplying an empty map for the source attribute values and `null` for the `AnnotatedElement`.

      参数:
        `annotationType` - the type of annotation to synthesize
      返回:
        the synthesized annotation
      抛出:
        `IllegalArgumentException` - if a required attribute is missing
        `AnnotationConfigurationException` - if invalid configuration of `@AliasFor` is detected
      从以下版本开始:
        4.2
      另请参阅:
        `synthesizeAnnotation(Map, Class, AnnotatedElement)`, `synthesizeAnnotation(Annotation, AnnotatedElement)`

    - #### clearCache

          public static void clearCache()

      Clear the internal annotation metadata cache.
      从以下版本开始:
        4.3.15