org.springframework.core.type

## Class StandardAnnotationMetadata

- java.lang.Object
- - org.springframework.core.type.StandardClassMetadata
  - - org.springframework.core.type.StandardAnnotationMetadata

- All Implemented Interfaces:
    AnnotationMetadata, ClassMetadata

      public class StandardAnnotationMetadata
      extends StandardClassMetadata
      implements AnnotationMetadata

  `AnnotationMetadata` implementation that uses standard reflection to introspect a given `Class`.
  Since:
    2.5
  Author:
    Juergen Hoeller, Mark Fisher, Chris Beams

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `StandardAnnotationMetadata(Class<?> introspectedClass)` Create a new `StandardAnnotationMetadata` wrapper for the given Class.
    `StandardAnnotationMetadata(Class<?> introspectedClass, boolean nestedAnnotationsAsMap)` Create a new `StandardAnnotationMetadata` wrapper for the given Class, providing the option to return any nested annotations or annotation arrays in the form of `AnnotationAttributes` instead of actual `Annotation` instances.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Set<MethodMetadata>` | `getAnnotatedMethods(String annotationType)` Retrieve the method metadata for all methods that are annotated (or meta-annotated) with the given annotation type.
    `Map<String,Object>` | `getAnnotationAttributes(String annotationType)` Retrieve the attributes of the annotation of the given type, if any (i.e.
    `Map<String,Object>` | `getAnnotationAttributes(String annotationType, boolean classValuesAsString)` Retrieve the attributes of the annotation of the given type, if any (i.e.
    `Set<String>` | `getAnnotationTypes()` Return the names of all annotation types defined on the underlying class.
    `Set<String>` | `getMetaAnnotationTypes(String annotationType)` Return the names of all meta-annotation types defined on the given annotation type of the underlying class.
    `boolean` | `hasAnnotatedMethods(String annotationType)` Determine whether the underlying class has any methods that are annotated (or meta-annotated) with the given annotation type.
    `boolean` | `hasAnnotation(String annotationType)` Determine whether the underlying class has an annotation of the given type defined.
    `boolean` | `hasMetaAnnotation(String annotationType)` Determine whether the underlying class has an annotation that is itself annotated with the meta-annotation of the given type.
    `boolean` | `isAnnotated(String annotationType)` Determine whether the underlying class has an annotation or meta-annotation of the given type defined.

    - ### Methods inherited from class org.springframework.core.type.StandardClassMetadata

      `getClassName, getEnclosingClassName, getInterfaceNames, getIntrospectedClass, getMemberClassNames, getSuperClassName, hasEnclosingClass, hasSuperClass, isAbstract, isConcrete, isFinal, isIndependent, isInterface`

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface org.springframework.core.type.ClassMetadata

      `getClassName, getEnclosingClassName, getInterfaceNames, getMemberClassNames, getSuperClassName, hasEnclosingClass, hasSuperClass, isAbstract, isConcrete, isFinal, isIndependent, isInterface`

- - ### Constructor Detail

    - #### StandardAnnotationMetadata

          public StandardAnnotationMetadata(Class<?> introspectedClass)

      Create a new `StandardAnnotationMetadata` wrapper for the given Class.
      Parameters:
        `introspectedClass` - the Class to introspect
      See Also:
        `StandardAnnotationMetadata(Class, boolean)`

    - #### StandardAnnotationMetadata

          public StandardAnnotationMetadata(Class<?> introspectedClass,
                                    boolean nestedAnnotationsAsMap)

      Create a new `StandardAnnotationMetadata` wrapper for the given Class, providing the option to return any nested annotations or annotation arrays in the form of `AnnotationAttributes` instead of actual `Annotation` instances.
      Parameters:
        `introspectedClass` - the Class to instrospect
        `nestedAnnotationsAsMap` - return nested annotations and annotation arrays as `AnnotationAttributes` for compatibility with ASM-based `AnnotationMetadata` implementations
      Since:
        3.1.1

  - ### Method Detail

    - #### getAnnotationTypes

          public Set<String> getAnnotationTypes()

      Description copied from interface: `AnnotationMetadata`
      Return the names of all annotation types defined on the underlying class.
      Specified by:
        `getAnnotationTypes` in interface `AnnotationMetadata`
      Returns:
        the annotation type names

    - #### getMetaAnnotationTypes

          public Set<String> getMetaAnnotationTypes(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Return the names of all meta-annotation types defined on the given annotation type of the underlying class.
      Specified by:
        `getMetaAnnotationTypes` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the meta-annotation type to look for
      Returns:
        the meta-annotation type names

    - #### hasAnnotation

          public boolean hasAnnotation(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Determine whether the underlying class has an annotation of the given type defined.
      Specified by:
        `hasAnnotation` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the annotation type to look for
      Returns:
        whether a matching annotation is defined

    - #### hasMetaAnnotation

          public boolean hasMetaAnnotation(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Determine whether the underlying class has an annotation that is itself annotated with the meta-annotation of the given type.
      Specified by:
        `hasMetaAnnotation` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the meta-annotation type to look for
      Returns:
        whether a matching meta-annotation is defined

    - #### isAnnotated

          public boolean isAnnotated(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Determine whether the underlying class has an annotation or meta-annotation of the given type defined.

      This is equivalent to a "hasAnnotation || hasMetaAnnotation" check. If this method returns `true`, then `AnnotationMetadata.getAnnotationAttributes(java.lang.String)` will return a non-null Map.

      Specified by:
        `isAnnotated` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the annotation type to look for
      Returns:
        whether a matching annotation is defined

    - #### getAnnotationAttributes

          public Map<String,Object> getAnnotationAttributes(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying class, as direct annotation or as meta-annotation).
      Specified by:
        `getAnnotationAttributes` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the annotation type to look for
      Returns:
        a Map of attributes, with the attribute name as key (e.g. "value") and the defined attribute value as Map value. This return value will be `null` if no matching annotation is defined.

    - #### getAnnotationAttributes

          public Map<String,Object> getAnnotationAttributes(String annotationType,
                                                   boolean classValuesAsString)

      Description copied from interface: `AnnotationMetadata`
      Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying class, as direct annotation or as meta-annotation).
      Specified by:
        `getAnnotationAttributes` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the annotation type to look for
        `classValuesAsString` - whether to convert class references to String class names for exposure as values in the returned Map, instead of Class references which might potentially have to be loaded first
      Returns:
        a Map of attributes, with the attribute name as key (e.g. "value") and the defined attribute value as Map value. This return value will be `null` if no matching annotation is defined.

    - #### hasAnnotatedMethods

          public boolean hasAnnotatedMethods(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Determine whether the underlying class has any methods that are annotated (or meta-annotated) with the given annotation type.
      Specified by:
        `hasAnnotatedMethods` in interface `AnnotationMetadata`

    - #### getAnnotatedMethods

          public Set<MethodMetadata> getAnnotatedMethods(String annotationType)

      Description copied from interface: `AnnotationMetadata`
      Retrieve the method metadata for all methods that are annotated (or meta-annotated) with the given annotation type.

      For any returned method, `MethodMetadata.isAnnotated(java.lang.String)` will return `true` for the given annotation type.

      Specified by:
        `getAnnotatedMethods` in interface `AnnotationMetadata`
      Parameters:
        `annotationType` - the annotation type to look for
      Returns:
        a Set of `MethodMetadata` for methods that have a matching annotation. The return value will be an empty set if no methods match the annotation type.