org.springframework.core.annotation

Class AnnotationUtils

java.lang.Object

org.springframework.core.annotation.AnnotationUtils

public abstract class AnnotationUtils
extends java.lang.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 annotations (e.g. for transaction control, authorization, or service exposure), always use the lookup methods on this class (e.g., findAnnotation(Method, Class), getAnnotation(Method, Class), and getAnnotations(Method)) 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.

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 support for meta-annotations with attribute overrides in composed annotations, use AnnotatedElementUtils 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.

Since:

2.0

Author:

Rob Harrop, Juergen Hoeller, Sam Brannen, Mark Fisher, Chris Beams, Phillip Webb

See Also:

AliasFor, AnnotationAttributes, AnnotatedElementUtils, BridgeMethodResolver, AnnotatedElement.getAnnotations(), AnnotatedElement.getAnnotation(Class), AnnotatedElement.getDeclaredAnnotations()

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	AnnotationUtils.AnnotationCacheKey Cache key for the AnnotatedElement cache.
private static class	AnnotationUtils.AnnotationCollector<A extends java.lang.annotation.Annotation>

Field Summary

Fields

Modifier and Type	Field and Description
private static java.util.Map<java.lang.Class<?>,java.lang.Boolean>	annotatedInterfaceCache
private static java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Map<java.lang.String,java.lang.String>>	attributeAliasesCache
private static java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.List<java.lang.reflect.Method>>	attributeMethodsCache
private static java.lang.Object	DEFAULT_VALUE_PLACEHOLDER An object that can be stored in AnnotationAttributes as a placeholder for an attribute's declared default value.
private static java.util.Map<AnnotationUtils.AnnotationCacheKey,java.lang.annotation.Annotation>	findAnnotationCache
private static Log	logger
private static java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.lang.Boolean>	synthesizableCache
static java.lang.String	VALUE The attribute name for annotations with a single element.

Constructor Summary

Constructors

Constructor and Description
AnnotationUtils()

Method Summary

Modifier and Type	Method and Description
(package private) static java.lang.Object	adaptValue(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Object value, boolean classValuesAsString, boolean nestedAnnotationsAsMap) Adapt the given value according to the given class and nested annotation settings.
static <A extends java.lang.annotation.Annotation> A	findAnnotation(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<A> annotationType) Find a single Annotation of annotationType on the supplied AnnotatedElement.
private static <A extends java.lang.annotation.Annotation> A	findAnnotation(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<A> annotationType, java.util.Set<java.lang.annotation.Annotation> visited) Perform the search algorithm for findAnnotation(AnnotatedElement, Class) avoiding endless recursion by tracking which annotations have already been visited.
static <A extends java.lang.annotation.Annotation> A	findAnnotation(java.lang.Class<?> clazz, java.lang.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.
private static <A extends java.lang.annotation.Annotation> A	findAnnotation(java.lang.Class<?> clazz, java.lang.Class<A> annotationType, java.util.Set<java.lang.annotation.Annotation> visited) Perform the search algorithm for findAnnotation(Class, Class), avoiding endless recursion by tracking which annotations have already been visited.
static <A extends java.lang.annotation.Annotation> A	findAnnotation(java.lang.reflect.Method method, java.lang.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 java.lang.Class<?>	findAnnotationDeclaringClass(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.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 java.lang.Class<?>	findAnnotationDeclaringClassForTypes(java.util.List<java.lang.Class<? extends java.lang.annotation.Annotation>> annotationTypes, java.lang.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.
(package private) static java.lang.String	getAliasedAttributeName(java.lang.reflect.Method attribute) Get the name of the aliased attribute configured via @AliasFor on the supplied annotation attribute.
(package private) static java.lang.String	getAliasedAttributeName(java.lang.reflect.Method attribute, java.lang.Class<? extends java.lang.annotation.Annotation> targetAnnotationType) Get the name of the aliased attribute configured via @AliasFor on the supplied annotation attribute.
static <A extends java.lang.annotation.Annotation> A	getAnnotation(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.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.
(package private) static java.lang.annotation.Annotation	getAnnotation(java.lang.reflect.AnnotatedElement element, java.lang.String annotationName) Get the annotation with the supplied annotationName on the supplied element.
static <A extends java.lang.annotation.Annotation> A	getAnnotation(java.lang.annotation.Annotation ann, java.lang.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 java.lang.annotation.Annotation> A	getAnnotation(java.lang.reflect.Method method, java.lang.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(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.annotation.Annotation annotation) Retrieve the given annotation's attributes as an AnnotationAttributes map.
static AnnotationAttributes	getAnnotationAttributes(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.annotation.Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap) Retrieve the given annotation's attributes as an AnnotationAttributes map.
(package private) static AnnotationAttributes	getAnnotationAttributes(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.annotation.Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap, boolean mergeMode) Retrieve the given annotation's attributes as an AnnotationAttributes map.
static java.util.Map<java.lang.String,java.lang.Object>	getAnnotationAttributes(java.lang.annotation.Annotation annotation) Retrieve the given annotation's attributes as a Map, preserving all attribute types.
static java.util.Map<java.lang.String,java.lang.Object>	getAnnotationAttributes(java.lang.annotation.Annotation annotation, boolean classValuesAsString) Retrieve the given annotation's attributes as a Map.
static AnnotationAttributes	getAnnotationAttributes(java.lang.annotation.Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap) Retrieve the given annotation's attributes as an AnnotationAttributes map.
static java.lang.annotation.Annotation[]	getAnnotations(java.lang.reflect.AnnotatedElement annotatedElement) Get all Annotations that are present on the supplied AnnotatedElement.
static java.lang.annotation.Annotation[]	getAnnotations(java.lang.reflect.Method method) Get all Annotations that are present on the supplied Method.
(package private) static java.util.Map<java.lang.String,java.lang.String>	getAttributeAliasMap(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) Get a map of all attribute alias pairs, declared via @AliasFor in the supplied annotation type.
(package private) static java.util.List<java.lang.reflect.Method>	getAttributeMethods(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) Get all methods declared in the supplied annotationType that match Java's requirements for annotation attributes.
static <A extends java.lang.annotation.Annotation> java.util.Set<A>	getDeclaredRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.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 java.lang.annotation.Annotation> java.util.Set<A>	getDeclaredRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<A> annotationType, java.lang.Class<? extends java.lang.annotation.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 java.lang.Object	getDefaultValue(java.lang.annotation.Annotation annotation) Retrieve the default value of the value attribute of a single-element Annotation, given an annotation instance.
static java.lang.Object	getDefaultValue(java.lang.annotation.Annotation annotation, java.lang.String attributeName) Retrieve the default value of a named attribute, given an annotation instance.
static java.lang.Object	getDefaultValue(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) Retrieve the default value of the value attribute of a single-element Annotation, given the annotation type.
static java.lang.Object	getDefaultValue(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.String attributeName) Retrieve the default value of a named attribute, given the annotation type.
static <A extends java.lang.annotation.Annotation> java.util.Set<A>	getRepeatableAnnotation(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType, java.lang.Class<A> annotationType) Deprecated. As of Spring Framework 4.2, use getRepeatableAnnotations() or getDeclaredRepeatableAnnotations() instead.
static <A extends java.lang.annotation.Annotation> java.util.Set<A>	getRepeatableAnnotation(java.lang.reflect.Method method, java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType, java.lang.Class<A> annotationType) Deprecated. As of Spring Framework 4.2, use getRepeatableAnnotations() or getDeclaredRepeatableAnnotations() instead.
static <A extends java.lang.annotation.Annotation> java.util.Set<A>	getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.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 java.lang.annotation.Annotation> java.util.Set<A>	getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<A> annotationType, java.lang.Class<? extends java.lang.annotation.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.
private static <A extends java.lang.annotation.Annotation> java.util.Set<A>	getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Class<A> annotationType, java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType, boolean declaredMode) Perform the actual work for getRepeatableAnnotations(AnnotatedElement, Class, Class) and getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class).
static java.lang.Object	getValue(java.lang.annotation.Annotation annotation) Retrieve the value of the value attribute of a single-element Annotation, given an annotation instance.
static java.lang.Object	getValue(java.lang.annotation.Annotation annotation, java.lang.String attributeName) Retrieve the value of a named attribute, given an annotation instance.
(package private) static void	handleIntrospectionFailure(java.lang.reflect.AnnotatedElement element, java.lang.Exception ex) Handle the supplied annotation introspection exception.
static boolean	isAnnotationDeclaredLocally(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class<?> clazz) Determine whether an annotation of the specified annotationType is declared locally (i.e., directly present) on the supplied clazz.
static boolean	isAnnotationInherited(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class<?> clazz) Determine whether an annotation of the specified annotationType is present on the supplied clazz and is inherited (i.e., not directly present).
(package private) static boolean	isAnnotationTypeMethod(java.lang.reflect.Method method) Determine if the supplied method is an "annotationType" method.
(package private) static boolean	isAttributeMethod(java.lang.reflect.Method method) Determine if the supplied method is an annotation attribute method.
static boolean	isInJavaLangAnnotationPackage(java.lang.annotation.Annotation annotation) Determine if the supplied Annotation is defined in the core JDK java.lang.annotation package.
static boolean	isInJavaLangAnnotationPackage(java.lang.String annotationType) Determine if the Annotation with the supplied name is defined in the core JDK java.lang.annotation package.
(package private) static boolean	isInterfaceWithAnnotatedMethods(java.lang.Class<?> iface)
private static boolean	isSynthesizable(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) Determine if annotations of the supplied annotationType are synthesizable (i.e., in need of being wrapped in a dynamic proxy that provides functionality above that of a standard JDK annotation).
(package private) static void	postProcessAnnotationAttributes(java.lang.reflect.AnnotatedElement element, AnnotationAttributes attributes, boolean classValuesAsString, boolean nestedAnnotationsAsMap) Post-process the supplied AnnotationAttributes.
(package private) static void	rethrowAnnotationConfigurationException(java.lang.Throwable ex) If the supplied throwable is an AnnotationConfigurationException, it will be cast to an AnnotationConfigurationException and thrown, allowing it to propagate to the caller.
private static <A extends java.lang.annotation.Annotation> A	searchOnInterfaces(java.lang.reflect.Method method, java.lang.Class<A> annotationType, java.lang.Class<?>... ifcs)
(package private) static <A extends java.lang.annotation.Annotation> A	synthesizeAnnotation(A annotation) 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 java.lang.annotation.Annotation> A	synthesizeAnnotation(A annotation, java.lang.reflect.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 java.lang.annotation.Annotation> A	synthesizeAnnotation(java.lang.Class<A> annotationType) Synthesize an annotation from its default attributes values.
static <A extends java.lang.annotation.Annotation> A	synthesizeAnnotation(java.util.Map<java.lang.String,java.lang.Object> attributes, java.lang.Class<A> annotationType, java.lang.reflect.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 java.lang.annotation.Annotation[]	synthesizeAnnotationArray(java.lang.annotation.Annotation[] annotations, java.lang.reflect.AnnotatedElement annotatedElement) Synthesize the supplied array of annotations by creating a new array of the same size and type and populating it with synthesized versions of the annotations from the input array.

Methods inherited from class java.lang.Object

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

Field Detail

VALUE

public static final java.lang.String VALUE

The attribute name for annotations with a single element.

See Also:

Constant Field Values

DEFAULT_VALUE_PLACEHOLDER

private static final java.lang.Object DEFAULT_VALUE_PLACEHOLDER

An object that can be stored in AnnotationAttributes as a placeholder for an attribute's declared default value.

findAnnotationCache

private static final java.util.Map<AnnotationUtils.AnnotationCacheKey,java.lang.annotation.Annotation> findAnnotationCache

annotatedInterfaceCache

private static final java.util.Map<java.lang.Class<?>,java.lang.Boolean> annotatedInterfaceCache

synthesizableCache

private static final java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.lang.Boolean> synthesizableCache

attributeAliasesCache

private static final java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Map<java.lang.String,java.lang.String>> attributeAliasesCache

attributeMethodsCache

private static final java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.List<java.lang.reflect.Method>> attributeMethodsCache

logger

private static transient Log logger

Constructor Detail

AnnotationUtils

public AnnotationUtils()

Method Detail

getAnnotation

public static <A extends java.lang.annotation.Annotation> A getAnnotation(java.lang.annotation.Annotation ann,
                                                                          java.lang.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.

Parameters:

ann - the Annotation to check

annotationType - the annotation type to look for, both locally and as a meta-annotation

Returns:

the first matching annotation, or null if not found

Since:

4.0

getAnnotation

public static <A extends java.lang.annotation.Annotation> A getAnnotation(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                          java.lang.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.

Parameters:

annotatedElement - the AnnotatedElement from which to get the annotation

annotationType - the annotation type to look for, both locally and as a meta-annotation

Returns:

the first matching annotation, or null if not found

Since:

3.1

getAnnotation

public static <A extends java.lang.annotation.Annotation> A getAnnotation(java.lang.reflect.Method method,
                                                                          java.lang.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.

Parameters:

method - the method to look for annotations on

annotationType - the annotation type to look for

Returns:

the first matching annotation, or null if not found

See Also:

BridgeMethodResolver.findBridgedMethod(Method), getAnnotation(AnnotatedElement, Class)

getAnnotations

public static java.lang.annotation.Annotation[] getAnnotations(java.lang.reflect.AnnotatedElement annotatedElement)

Get all Annotations that are present on the supplied AnnotatedElement.

Meta-annotations will not be searched.

Parameters:

annotatedElement - the Method, Constructor or Field to retrieve annotations from

Returns:

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)

Since:

4.0.8

See Also:

AnnotatedElement.getAnnotations()

getAnnotations

public static java.lang.annotation.Annotation[] getAnnotations(java.lang.reflect.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.

Parameters:

method - the Method to retrieve annotations from

Returns:

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)

See Also:

BridgeMethodResolver.findBridgedMethod(Method), AnnotatedElement.getAnnotations()

getRepeatableAnnotation

@Deprecated
public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getRepeatableAnnotation(java.lang.reflect.Method method,
                                                                                                               java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType,
                                                                                                               java.lang.Class<A> annotationType)

Deprecated. As of Spring Framework 4.2, use getRepeatableAnnotations() or getDeclaredRepeatableAnnotations() instead.

Delegates to getRepeatableAnnotations(AnnotatedElement, Class, Class).

Since:

4.0

See Also:

getRepeatableAnnotations(AnnotatedElement, Class, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class)

getRepeatableAnnotation

@Deprecated
public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getRepeatableAnnotation(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                               java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType,
                                                                                                               java.lang.Class<A> annotationType)

Deprecated. As of Spring Framework 4.2, use getRepeatableAnnotations() or getDeclaredRepeatableAnnotations() instead.

Delegates to getRepeatableAnnotations(AnnotatedElement, Class, Class).

Since:

4.0

See Also:

getRepeatableAnnotations(AnnotatedElement, Class, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class)

getRepeatableAnnotations

public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                    java.lang.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.

Parameters:

annotatedElement - the element to look for annotations on; never null

annotationType - the annotation type to look for; never null

Returns:

the annotations found or an empty set; never null

Since:

4.2

See Also:

getRepeatableAnnotations(AnnotatedElement, Class, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class), BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method), Repeatable, AnnotatedElement.getAnnotationsByType(java.lang.Class<T>)

getRepeatableAnnotations

public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                    java.lang.Class<A> annotationType,
                                                                                                    java.lang.Class<? extends java.lang.annotation.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.

Parameters:

annotatedElement - the element to look for annotations on; never null

annotationType - the annotation type to look for; never null

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

Returns:

the annotations found or an empty set; never null

Since:

4.2

See Also:

getRepeatableAnnotations(AnnotatedElement, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class), BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method), Repeatable, AnnotatedElement.getAnnotationsByType(java.lang.Class<T>)

getDeclaredRepeatableAnnotations

public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getDeclaredRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                            java.lang.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.

Parameters:

annotatedElement - the element to look for annotations on; never null

annotationType - the annotation type to look for; never null

Returns:

the annotations found or an empty set; never null

Since:

4.2

See Also:

getRepeatableAnnotations(AnnotatedElement, Class), getRepeatableAnnotations(AnnotatedElement, Class, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class), BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method), Repeatable, AnnotatedElement.getDeclaredAnnotationsByType(java.lang.Class<T>)

getDeclaredRepeatableAnnotations

public static <A extends java.lang.annotation.Annotation> java.util.Set<A> getDeclaredRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                            java.lang.Class<A> annotationType,
                                                                                                            java.lang.Class<? extends java.lang.annotation.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.

Parameters:

annotatedElement - the element to look for annotations on; never null

annotationType - the annotation type to look for; never null

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

Returns:

the annotations found or an empty set; never null

Since:

4.2

See Also:

getRepeatableAnnotations(AnnotatedElement, Class), getRepeatableAnnotations(AnnotatedElement, Class, Class), getDeclaredRepeatableAnnotations(AnnotatedElement, Class), BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method), Repeatable, AnnotatedElement.getDeclaredAnnotationsByType(java.lang.Class<T>)

getRepeatableAnnotations

private static <A extends java.lang.annotation.Annotation> java.util.Set<A> getRepeatableAnnotations(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                                     java.lang.Class<A> annotationType,
                                                                                                     java.lang.Class<? extends java.lang.annotation.Annotation> containerAnnotationType,
                                                                                                     boolean declaredMode)

Perform the actual work for getRepeatableAnnotations(AnnotatedElement, Class, Class) and getDeclaredRepeatableAnnotations(AnnotatedElement, Class, Class).

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.

Parameters:

annotatedElement - the element to look for annotations on; never null

annotationType - the annotation type to look for; never null

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

declaredMode - true if only declared annotations (i.e., directly or indirectly present) should be considered.

Returns:

the annotations found or an empty set; never null

Since:

4.2

See Also:

BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method), Repeatable

findAnnotation

public static <A extends java.lang.annotation.Annotation> A findAnnotation(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                           java.lang.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.

Parameters:

annotatedElement - the AnnotatedElement on which to find the annotation

annotationType - the annotation type to look for, both locally and as a meta-annotation

Returns:

the first matching annotation, or null if not found

Since:

4.2

findAnnotation

private static <A extends java.lang.annotation.Annotation> A findAnnotation(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                            java.lang.Class<A> annotationType,
                                                                            java.util.Set<java.lang.annotation.Annotation> visited)

Perform the search algorithm for findAnnotation(AnnotatedElement, Class) avoiding endless recursion by tracking which annotations have already been visited.

Parameters:

annotatedElement - the AnnotatedElement on which to find the annotation

annotationType - the annotation type to look for, both locally and as a meta-annotation

visited - the set of annotations that have already been visited

Returns:

the first matching annotation, or null if not found

Since:

4.2

findAnnotation

public static <A extends java.lang.annotation.Annotation> A findAnnotation(java.lang.reflect.Method method,
                                                                           java.lang.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.

Parameters:

method - the method to look for annotations on

annotationType - the annotation type to look for

Returns:

the first matching annotation, or null if not found

See Also:

getAnnotation(Method, Class)

searchOnInterfaces

private static <A extends java.lang.annotation.Annotation> A searchOnInterfaces(java.lang.reflect.Method method,
                                                                                java.lang.Class<A> annotationType,
                                                                                java.lang.Class<?>... ifcs)

isInterfaceWithAnnotatedMethods

static boolean isInterfaceWithAnnotatedMethods(java.lang.Class<?> iface)

findAnnotation

public static <A extends java.lang.annotation.Annotation> A findAnnotation(java.lang.Class<?> clazz,
                                                                           java.lang.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.

Parameters:

clazz - the class to look for annotations on

annotationType - the type of annotation to look for

Returns:

the first matching annotation, or null if not found

findAnnotation

private static <A extends java.lang.annotation.Annotation> A findAnnotation(java.lang.Class<?> clazz,
                                                                            java.lang.Class<A> annotationType,
                                                                            java.util.Set<java.lang.annotation.Annotation> visited)

Perform the search algorithm for findAnnotation(Class, Class), avoiding endless recursion by tracking which annotations have already been visited.

Parameters:

clazz - the class to look for annotations on

annotationType - the type of annotation to look for

visited - the set of annotations that have already been visited

Returns:

the first matching annotation, or null if not found

findAnnotationDeclaringClass

public static java.lang.Class<?> findAnnotationDeclaringClass(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                                                              java.lang.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.

Parameters:

annotationType - the annotation type to look for

clazz - the class to check for the annotation on (may be null)

Returns:

the first Class in the inheritance hierarchy that declares an annotation of the specified annotationType, or null if not found

See Also:

Class.isAnnotationPresent(Class), Class.getDeclaredAnnotations(), findAnnotationDeclaringClassForTypes(List, Class), isAnnotationDeclaredLocally(Class, Class)

findAnnotationDeclaringClassForTypes

public static java.lang.Class<?> findAnnotationDeclaringClassForTypes(java.util.List<java.lang.Class<? extends java.lang.annotation.Annotation>> annotationTypes,
                                                                      java.lang.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.

Parameters:

annotationTypes - the annotation types to look for

clazz - the class to check for the annotations on, or null

Returns:

the first Class in the inheritance hierarchy that declares an annotation of at least one of the specified annotationTypes, or null if not found

Since:

3.2.2

See Also:

Class.isAnnotationPresent(Class), Class.getDeclaredAnnotations(), findAnnotationDeclaringClass(Class, Class), isAnnotationDeclaredLocally(Class, Class)

isAnnotationDeclaredLocally

public static boolean isAnnotationDeclaredLocally(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                                                  java.lang.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.

Parameters:

annotationType - the annotation type to look for

clazz - the class to check for the annotation on

Returns:

true if an annotation of the specified annotationType is directly present

See Also:

Class.getDeclaredAnnotations(), Class.getDeclaredAnnotation(Class), isAnnotationInherited(Class, Class)

isAnnotationInherited

public static boolean isAnnotationInherited(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                                            java.lang.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.

Parameters:

annotationType - the annotation type to look for

clazz - the class to check for the annotation on

Returns:

true if an annotation of the specified annotationType is present and inherited

See Also:

Class.isAnnotationPresent(Class), isAnnotationDeclaredLocally(Class, Class)

isInJavaLangAnnotationPackage

public static boolean isInJavaLangAnnotationPackage(java.lang.annotation.Annotation annotation)

Determine if the supplied Annotation is defined in the core JDK java.lang.annotation package.

Parameters:

annotation - the annotation to check (never null)

Returns:

true if the annotation is in the java.lang.annotation package

isInJavaLangAnnotationPackage

public static boolean isInJavaLangAnnotationPackage(java.lang.String annotationType)

Determine if the Annotation with the supplied name is defined in the core JDK java.lang.annotation package.

Parameters:

annotationType - the name of the annotation type to check (never null or empty)

Returns:

true if the annotation is in the java.lang.annotation package

Since:

4.2

getAnnotationAttributes

public static java.util.Map<java.lang.String,java.lang.Object> getAnnotationAttributes(java.lang.annotation.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.

Parameters:

annotation - the annotation to retrieve the attributes for

Returns:

the Map of annotation attributes, with attribute names as keys and corresponding attribute values as values; never null

See Also:

getAnnotationAttributes(AnnotatedElement, Annotation), getAnnotationAttributes(Annotation, boolean, boolean), getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)

getAnnotationAttributes

public static java.util.Map<java.lang.String,java.lang.Object> getAnnotationAttributes(java.lang.annotation.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.

Parameters:

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

Returns:

the Map of annotation attributes, with attribute names as keys and corresponding attribute values as values; never null

See Also:

getAnnotationAttributes(Annotation, boolean, boolean)

getAnnotationAttributes

public static AnnotationAttributes getAnnotationAttributes(java.lang.annotation.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.

Parameters:

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

Returns:

the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values; never null

Since:

3.1.1

getAnnotationAttributes

public static AnnotationAttributes getAnnotationAttributes(java.lang.reflect.AnnotatedElement annotatedElement,
                                                           java.lang.annotation.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.

Parameters:

annotatedElement - the element that is annotated with the supplied annotation; may be null if unknown

annotation - the annotation to retrieve the attributes for

Returns:

the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values; never null

Since:

4.2

See Also:

getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean)

getAnnotationAttributes

public static AnnotationAttributes getAnnotationAttributes(java.lang.reflect.AnnotatedElement annotatedElement,
                                                           java.lang.annotation.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.

Parameters:

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

Returns:

the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values; never null

Since:

4.2

getAnnotationAttributes

static AnnotationAttributes getAnnotationAttributes(java.lang.reflect.AnnotatedElement annotatedElement,
                                                    java.lang.annotation.Annotation annotation,
                                                    boolean classValuesAsString,
                                                    boolean nestedAnnotationsAsMap,
                                                    boolean mergeMode)

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.

NOTE: This variant of getAnnotationAttributes() is only intended for use within the framework. Specifically, the mergeMode flag can be set to true in order to support processing of attribute aliases while merging attributes within an annotation hierarchy. When running in merge mode, the following special rules apply:

1. The supplied annotation will not be synthesized before retrieving its attributes; however, nested annotations and arrays of nested annotations will be synthesized.
2. Default values will be replaced with DEFAULT_VALUE_PLACEHOLDER.
3. The resulting, merged annotation attributes should eventually be post-processed in order to ensure that placeholders have been replaced by actual default values and in order to enforce @AliasFor semantics.

Parameters:

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

mergeMode - whether the annotation attributes should be created using merge mode

Returns:

the annotation attributes (a specialized Map) with attribute names as keys and corresponding attribute values as values; never null

Since:

4.2

See Also:

postProcessAnnotationAttributes(java.lang.reflect.AnnotatedElement, org.springframework.core.annotation.AnnotationAttributes, boolean, boolean)

adaptValue

static java.lang.Object adaptValue(java.lang.reflect.AnnotatedElement annotatedElement,
                                   java.lang.Object value,
                                   boolean classValuesAsString,
                                   boolean nestedAnnotationsAsMap)

Adapt the given value according to the given class and nested annotation settings.

Nested annotations will be synthesized.

Parameters:

annotatedElement - the element that is annotated, used for contextual logging; may be null if unknown

value - the annotation attribute value

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

Returns:

the adapted value, or the original value if no adaptation is needed

getValue

public static java.lang.Object getValue(java.lang.annotation.Annotation annotation)

Retrieve the value of the value attribute of a single-element Annotation, given an annotation instance.

Parameters:

annotation - the annotation instance from which to retrieve the value

Returns:

the attribute value, or null if not found

See Also:

getValue(Annotation, String)

getValue

public static java.lang.Object getValue(java.lang.annotation.Annotation annotation,
                                        java.lang.String attributeName)

Retrieve the value of a named attribute, given an annotation instance.

Parameters:

annotation - the annotation instance from which to retrieve the value

attributeName - the name of the attribute value to retrieve

Returns:

the attribute value, or null if not found

See Also:

getValue(Annotation)

getDefaultValue

public static java.lang.Object getDefaultValue(java.lang.annotation.Annotation annotation)

Retrieve the default value of the value attribute of a single-element Annotation, given an annotation instance.

Parameters:

annotation - the annotation instance from which to retrieve the default value

Returns:

the default value, or null if not found

See Also:

getDefaultValue(Annotation, String)

getDefaultValue

public static java.lang.Object getDefaultValue(java.lang.annotation.Annotation annotation,
                                               java.lang.String attributeName)

Retrieve the default value of a named attribute, given an annotation instance.

Parameters:

annotation - the annotation instance from which to retrieve the default value

attributeName - the name of the attribute value to retrieve

Returns:

the default value of the named attribute, or null if not found

See Also:

getDefaultValue(Class, String)

getDefaultValue

public static java.lang.Object getDefaultValue(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)

Retrieve the default value of the value attribute of a single-element Annotation, given the annotation type.

Parameters:

annotationType - the annotation type for which the default value should be retrieved

Returns:

the default value, or null if not found

See Also:

getDefaultValue(Class, String)

getDefaultValue

public static java.lang.Object getDefaultValue(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                                               java.lang.String attributeName)

Retrieve the default value of a named attribute, given the annotation type.

Parameters:

annotationType - the annotation type for which the default value should be retrieved

attributeName - the name of the attribute value to retrieve.

Returns:

the default value of the named attribute, or null if not found

See Also:

getDefaultValue(Annotation, String)

synthesizeAnnotation

static <A extends java.lang.annotation.Annotation> A synthesizeAnnotation(A annotation)

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.

Parameters:

annotation - the annotation to synthesize

Returns:

the synthesized annotation, if the supplied annotation is synthesizable; null if the supplied annotation is null; otherwise, the supplied annotation unmodified

Throws:

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

See Also:

synthesizeAnnotation(Annotation, AnnotatedElement)

synthesizeAnnotation

public static <A extends java.lang.annotation.Annotation> A synthesizeAnnotation(A annotation,
                                                                                 java.lang.reflect.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.

Parameters:

annotation - the annotation to synthesize

annotatedElement - the element that is annotated with the supplied annotation; may be null if unknown

Returns:

the synthesized annotation if the supplied annotation is synthesizable; null if the supplied annotation is null; otherwise the supplied annotation unmodified

Throws:

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

See Also:

synthesizeAnnotation(Map, Class, AnnotatedElement), synthesizeAnnotation(Class)

synthesizeAnnotation

public static <A extends java.lang.annotation.Annotation> A synthesizeAnnotation(java.util.Map<java.lang.String,java.lang.Object> attributes,
                                                                                 java.lang.Class<A> annotationType,
                                                                                 java.lang.reflect.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.

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

Parameters:

attributes - the map of annotation attributes to synthesize

annotationType - the type of annotation to synthesize; never null

annotatedElement - the element that is annotated with the annotation corresponding to the supplied attributes; may be null if unknown

Returns:

the synthesized annotation, or null if the supplied attributes map is null

Throws:

java.lang.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

Since:

4.2

See Also:

synthesizeAnnotation(Annotation, AnnotatedElement), synthesizeAnnotation(Class)

synthesizeAnnotation

public static <A extends java.lang.annotation.Annotation> A synthesizeAnnotation(java.lang.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.

Parameters:

annotationType - the type of annotation to synthesize; never null

Returns:

the synthesized annotation

Throws:

java.lang.IllegalArgumentException - if a required attribute is missing

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

See Also:

synthesizeAnnotation(Map, Class, AnnotatedElement), synthesizeAnnotation(Annotation, AnnotatedElement)

synthesizeAnnotationArray

public static java.lang.annotation.Annotation[] synthesizeAnnotationArray(java.lang.annotation.Annotation[] annotations,
                                                                          java.lang.reflect.AnnotatedElement annotatedElement)

Synthesize the supplied array of annotations by creating a new array of the same size and type and populating it with synthesized versions of the annotations from the input array.

Parameters:

annotations - the array of annotations to synthesize

annotatedElement - the element that is annotated with the supplied array of annotations; may be null if unknown

Returns:

a new array of synthesized annotations, or null if the supplied array is null

Throws:

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

See Also:

synthesizeAnnotation(Annotation, AnnotatedElement), synthesizeAnnotation(Map, Class, AnnotatedElement)

getAttributeAliasMap

static java.util.Map<java.lang.String,java.lang.String> getAttributeAliasMap(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)

Get a map of all attribute alias pairs, declared via @AliasFor in the supplied annotation type.

The map is keyed by attribute name with each value representing the name of the aliased attribute. For each entry [x, y] in the map there will be a corresponding [y, x] entry in the map.

An empty return value implies that the annotation does not declare any attribute aliases.

Parameters:

annotationType - the annotation type to find attribute aliases in

Returns:

a map containing attribute alias pairs; never null

Since:

4.2

isSynthesizable

private static boolean isSynthesizable(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)

Determine if annotations of the supplied annotationType are synthesizable (i.e., in need of being wrapped in a dynamic proxy that provides functionality above that of a standard JDK annotation).

Specifically, an annotation is synthesizable if it declares any attributes that are configured as aliased pairs via @AliasFor or if any nested annotations used by the annotation declare such aliased pairs.

Since:

4.2

See Also:

SynthesizedAnnotation, SynthesizedAnnotationInvocationHandler

getAliasedAttributeName

static java.lang.String getAliasedAttributeName(java.lang.reflect.Method attribute)

Get the name of the aliased attribute configured via @AliasFor on the supplied annotation attribute.

This method does not resolve aliases in other annotations. In other words, if @AliasFor is present on the supplied attribute but references an annotation other than Annotation, this method will return null immediately.

Parameters:

attribute - the attribute to find an alias for

Returns:

the name of the aliased attribute, or null if not found

Throws:

java.lang.IllegalArgumentException - if the supplied attribute method is not from an annotation, or if the supplied target type is Annotation

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

See Also:

getAliasedAttributeName(Method, Class)

getAliasedAttributeName

static java.lang.String getAliasedAttributeName(java.lang.reflect.Method attribute,
                                                java.lang.Class<? extends java.lang.annotation.Annotation> targetAnnotationType)

Get the name of the aliased attribute configured via @AliasFor on the supplied annotation attribute.

Parameters:

attribute - the attribute to find an alias for

targetAnnotationType - the type of annotation in which the aliased attribute is allowed to be declared; null implies within the same annotation

Returns:

the name of the aliased attribute, or null if not found

Throws:

java.lang.IllegalArgumentException - if the supplied attribute method is not from an annotation, or if the supplied target type is Annotation

AnnotationConfigurationException - if invalid configuration of @AliasFor is detected

Since:

4.2

getAttributeMethods

static java.util.List<java.lang.reflect.Method> getAttributeMethods(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)

Get all methods declared in the supplied annotationType that match Java's requirements for annotation attributes.

All methods in the returned list will be made accessible.

Parameters:

annotationType - the type in which to search for attribute methods; never null

Returns:

all annotation attribute methods in the specified annotation type; never null, though potentially empty

Since:

4.2

getAnnotation

static java.lang.annotation.Annotation getAnnotation(java.lang.reflect.AnnotatedElement element,
                                                     java.lang.String annotationName)

Get the annotation with the supplied annotationName on the supplied element.

Parameters:

element - the element to search on

annotationName - the fully qualified class name of the annotation type to find; never null or empty

Returns:

the annotation if found; null otherwise

Since:

4.2

isAttributeMethod

static boolean isAttributeMethod(java.lang.reflect.Method method)

Determine if the supplied method is an annotation attribute method.

Parameters:

method - the method to check

Returns:

true if the method is an attribute method

isAnnotationTypeMethod

static boolean isAnnotationTypeMethod(java.lang.reflect.Method method)

Determine if the supplied method is an "annotationType" method.

Returns:

true if the method is an "annotationType" method

See Also:

Annotation.annotationType()

postProcessAnnotationAttributes

static void postProcessAnnotationAttributes(java.lang.reflect.AnnotatedElement element,
                                            AnnotationAttributes attributes,
                                            boolean classValuesAsString,
                                            boolean nestedAnnotationsAsMap)

Post-process the supplied AnnotationAttributes.

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

Parameters:

element - 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

nestedAnnotationsAsMap - whether to convert nested annotations into AnnotationAttributes maps (for compatibility with AnnotationMetadata) or to preserve them as Annotation instances

Since:

4.2

See Also:

getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean, boolean), DEFAULT_VALUE_PLACEHOLDER, getDefaultValue(Class, String)

rethrowAnnotationConfigurationException

static void rethrowAnnotationConfigurationException(java.lang.Throwable ex)

If the supplied throwable is an AnnotationConfigurationException, it will be cast to an AnnotationConfigurationException and thrown, allowing it to propagate to the caller.

Otherwise, this method does nothing.

Parameters:

t - the throwable to inspect

Since:

4.2

handleIntrospectionFailure

static void handleIntrospectionFailure(java.lang.reflect.AnnotatedElement element,
                                       java.lang.Exception ex)

Handle the supplied annotation introspection exception.

If the supplied exception is an AnnotationConfigurationException, it will simply be thrown, allowing it to propagate to the caller, and nothing will be logged.

Otherwise, this method logs an introspection failure (in particular TypeNotPresentExceptions) before moving on, assuming nested Class values were not resolvable within annotation attributes and thereby effectively pretending there were no annotations on the specified element.

Parameters:

element - the element that we tried to introspect annotations on

ex - the exception that we encountered

See Also:

rethrowAnnotationConfigurationException(java.lang.Throwable)