GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Support repeatable annotations as composed annotations 

Prior to this commit, AnnotationUtils supported searching for
repeatable annotations even if the repeatable annotation was declared
on a custom stereotype annotation. However, there was no support for
merging of attributes in composed repeatable annotations. In other
words, it was not possible for a custom annotation to override
attributes in a repeatable annotation.

This commit addresses this by introducing
findMergedRepeatableAnnotations() methods in AnnotatedElementUtils.
These new methods provide full support for explicit annotation
attribute overrides configured via @AliasFor (as well as
convention-based overrides) with "find semantics".

Issue: SPR-13973
pull/1016/head
Sam Brannen 10 years ago
parent
63115ed6eb
commit
2535469099
3 changed files with 487 additions and 57 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 273
      spring-core/src/main/java/org/springframework/core/annotation/AnnotatedElementUtils.java
  2. 41
      spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java
  3. 230
      spring-core/src/test/java/org/springframework/core/annotation/ComposedRepeatableAnnotationsTests.java

273
spring-core/src/main/java/org/springframework/core/annotation/AnnotatedElementUtils.java
Unescape View File

@ -33,8 +33,8 @@ import org.springframework.util.LinkedMultiValueMap; @@ -33,8 +33,8 @@ import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
/**
* General utility methods for finding annotations and meta-annotations on
* {@link AnnotatedElement AnnotatedElements}.
* General utility methods for finding annotations, meta-annotations, and
* repeatable annotations on {@link AnnotatedElement AnnotatedElements}.
*
* <p>{@code AnnotatedElementUtils} defines the public API for Spring's
* meta-annotation programming model with support for <em>annotation attribute
@ -48,7 +48,8 @@ import org.springframework.util.MultiValueMap; @@ -48,7 +48,8 @@ import org.springframework.util.MultiValueMap;
* <p>Support for meta-annotations with <em>attribute overrides</em> in
* <em>composed annotations</em> is provided by all variants of the
* {@code getMergedAnnotationAttributes()}, {@code getMergedAnnotation()},
* {@code findMergedAnnotationAttributes()}, and {@code findMergedAnnotation()}
* {@code findMergedAnnotationAttributes()}, {@code findMergedAnnotation()},
* {@code findAllMergedAnnotations()}, and {@code findMergedRepeatableAnnotations()}
* methods.
*
* <h3>Find vs. Get Semantics</h3>
@ -96,6 +97,7 @@ public class AnnotatedElementUtils { @@ -96,6 +97,7 @@ public class AnnotatedElementUtils {
private static final Boolean CONTINUE = null;
private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
/**
* Build an adapted {@link AnnotatedElement} for the given annotations,
@ -266,6 +268,7 @@ public class AnnotatedElementUtils { @@ -266,6 +268,7 @@ public class AnnotatedElementUtils {
* @param annotationType the annotation type to find
* @return {@code true} if a matching annotation is present
* @since 4.2.3
* @see #hasAnnotation(AnnotatedElement, Class)
*/
public static boolean isAnnotated(AnnotatedElement element, final Class<? extends Annotation> annotationType) {
Assert.notNull(element, "AnnotatedElement must not be null");
@ -442,6 +445,7 @@ public class AnnotatedElementUtils { @@ -442,6 +445,7 @@ public class AnnotatedElementUtils {
* @param annotationType the annotation type to find
* @return {@code true} if a matching annotation is present
* @since 4.3
* @see #isAnnotated(AnnotatedElement, Class)
*/
public static boolean hasAnnotation(AnnotatedElement element, final Class<? extends Annotation> annotationType) {
Assert.notNull(element, "AnnotatedElement must not be null");
@ -470,6 +474,8 @@ public class AnnotatedElementUtils { @@ -470,6 +474,8 @@ public class AnnotatedElementUtils {
* the result back into an annotation of the specified {@code annotationType}.
* <p>{@link AliasFor @AliasFor} semantics are fully supported, both
* within a single annotation and within the annotation hierarchy.
* <p>This method follows <em>find semantics</em> as described in the
* {@linkplain AnnotatedElementUtils class-level javadoc}.
* @param element the annotated element
* @param annotationType the annotation type to find
* @return the merged, synthesized {@code Annotation}, or {@code null} if not found
@ -507,6 +513,8 @@ public class AnnotatedElementUtils { @@ -507,6 +513,8 @@ public class AnnotatedElementUtils {
* <p>This method delegates to {@link #findMergedAnnotationAttributes(AnnotatedElement, String, boolean, boolean)}
* (supplying {@code false} for {@code classValuesAsString} and {@code nestedAnnotationsAsMap})
* and {@link AnnotationUtils#synthesizeAnnotation(Map, Class, AnnotatedElement)}.
* <p>This method follows <em>find semantics</em> as described in the
* {@linkplain AnnotatedElementUtils class-level javadoc}.
* @param element the annotated element
* @param annotationName the fully qualified class name of the annotation type to find
* @return the merged, synthesized {@code Annotation}, or {@code null} if not found
@ -528,10 +536,12 @@ public class AnnotatedElementUtils { @@ -528,10 +536,12 @@ public class AnnotatedElementUtils {
* within the annotation hierarchy <em>above</em> the supplied {@code element};
* and for each annotation found, merge that annotation's attributes with
* <em>matching</em> attributes from annotations in lower levels of the annotation
* hierarchy, and synthesize the result back into an annotation of the specified
* hierarchy and synthesize the result back into an annotation of the specified
* {@code annotationType}.
* <p>{@link AliasFor @AliasFor} semantics are fully supported, both within a
* single annotation and within the annotation hierarchy.
* single annotation and within annotation hierarchies.
* <p>This method follows <em>find semantics</em> as described in the
* {@linkplain AnnotatedElementUtils class-level javadoc}.
* @param element the annotated element; never {@code null}
* @param annotationType the annotation type to find; never {@code null}
* @return the set of all merged, synthesized {@code Annotations} found, or an empty
@ -557,6 +567,93 @@ public class AnnotatedElementUtils { @@ -557,6 +567,93 @@ public class AnnotatedElementUtils {
return annotations;
}
/**
* Find all <em>repeatable annotations</em> of the specified {@code annotationType}
* within the annotation hierarchy <em>above</em> the supplied {@code element};
* and for each annotation found, merge that annotation's attributes with
* <em>matching</em> attributes from annotations in lower levels of the annotation
* hierarchy and synthesize the result back into an annotation of the specified
* {@code annotationType}.
* <p>The container type that holds the repeatable annotations will be looked up
* via {@link java.lang.annotation.Repeatable}.
* <p>{@link AliasFor @AliasFor} semantics are fully supported, both within a
* single annotation and within annotation hierarchies.
* <p>This method follows <em>find semantics</em> as described in the
* {@linkplain AnnotatedElementUtils class-level javadoc}.
* @param element the annotated element; never {@code null}
* @param annotationType the annotation type to find; never {@code null}
* @return the set of all merged repeatable {@code Annotations} found, or an empty
* set if none were found
* @since 4.3
* @see #findMergedAnnotation(AnnotatedElement, Class)
* @see #findAllMergedAnnotations(AnnotatedElement, Class)
* @see #findMergedRepeatableAnnotations(AnnotatedElement, Class, Class)
* @throws IllegalArgumentException if the {@code element} or {@code annotationType}
* is {@code null}, or if the container type cannot be resolved
*/
public static <A extends Annotation> Set<A> findMergedRepeatableAnnotations(AnnotatedElement element,
Class<A> annotationType) {
return findMergedRepeatableAnnotations(element, annotationType, null);
}
/**
* Find all <em>repeatable annotations</em> of the specified {@code annotationType}
* within the annotation hierarchy <em>above</em> the supplied {@code element};
* and for each annotation found, merge that annotation's attributes with
* <em>matching</em> attributes from annotations in lower levels of the annotation
* hierarchy and synthesize the result back into an annotation of the specified
* {@code annotationType}.
* <p>{@link AliasFor @AliasFor} semantics are fully supported, both within a
* single annotation and within annotation hierarchies.
* <p>This method follows <em>find semantics</em> as described in the
* {@linkplain AnnotatedElementUtils class-level javadoc}.
* @param element the annotated element; never {@code null}
* @param annotationType the annotation type to find; never {@code null}
* @param containerType the type of the container that holds the annotations;
* may be {@code null} if the container type should be looked up via
* {@link java.lang.annotation.Repeatable}
* @return the set of all merged repeatable {@code Annotations} found, or an empty
* set if none were found
* @since 4.3
* @see #findMergedAnnotation(AnnotatedElement, Class)
* @see #findAllMergedAnnotations(AnnotatedElement, Class)
* @throws IllegalArgumentException if the {@code element} or {@code annotationType}
* is {@code null}, or if the container type cannot be resolved
* @throws AnnotationConfigurationException if the supplied {@code containerType}
* is not a valid container annotation for the supplied {@code annotationType}
*/
public static <A extends Annotation> Set<A> findMergedRepeatableAnnotations(AnnotatedElement element,
Class<A> annotationType, Class<? extends Annotation> containerType) {
Assert.notNull(element, "AnnotatedElement must not be null");
Assert.notNull(annotationType, "annotationType must not be null");
if (containerType == null) {
containerType = AnnotationUtils.resolveContainerAnnotationType(annotationType);
if (containerType == null) {
throw new IllegalArgumentException(
"annotationType must be a repeatable annotation: failed to resolve container type for "
+ annotationType.getName());
}
}
else {
validateRepeatableContainerType(annotationType, containerType);
}
MergedAnnotationAttributesProcessor processor = new MergedAnnotationAttributesProcessor(annotationType, null,
false, false, true);
searchWithFindSemantics(element, annotationType, annotationType.getName(), containerType, processor);
Set<A> annotations = new LinkedHashSet<A>();
for (AnnotationAttributes attributes : processor.getAggregatedResults()) {
AnnotationUtils.postProcessAnnotationAttributes(element, attributes, false, false);
annotations.add(AnnotationUtils.synthesizeAnnotation(attributes, annotationType, element));
}
return annotations;
}
/**
* Find the first annotation of the specified {@code annotationType} within
* the annotation hierarchy <em>above</em> the supplied {@code element} and
@ -853,12 +950,37 @@ public class AnnotatedElementUtils { @@ -853,12 +950,37 @@ public class AnnotatedElementUtils {
* @return the result of the processor, potentially {@code null}
* @since 4.2
*/
private static <T> T searchWithFindSemantics(
AnnotatedElement element, Class<? extends Annotation> annotationType, String annotationName, Processor<T> processor) {
private static <T> T searchWithFindSemantics(AnnotatedElement element, Class<? extends Annotation> annotationType,
String annotationName, Processor<T> processor) {
return searchWithFindSemantics(element, annotationType, annotationName, null, processor);
}
/**
* Search for annotations of the specified {@code annotationName} or
* {@code annotationType} on the specified {@code element}, following
* <em>find semantics</em>.
* @param element the annotated element
* @param annotationType the annotation type to find
* @param annotationName the fully qualified class name of the annotation
* type to find (as an alternative to {@code annotationType})
* @param containerType the type of the container that holds repeatable
* annotations, or {@code null} if the annotation is not repeatable
* @param processor the processor to delegate to
* @return the result of the processor, potentially {@code null}
* @since 4.2
*/
private static <T> T searchWithFindSemantics(AnnotatedElement element, Class<? extends Annotation> annotationType,
String annotationName, Class<? extends Annotation> containerType, Processor<T> processor) {
if (containerType != null && !processor.aggregates()) {
throw new IllegalArgumentException(
"Searches for repeatable annotations must supply an aggregating Processor");
}
try {
return searchWithFindSemantics(
element, annotationType, annotationName, processor, new HashSet<AnnotatedElement>(), 0);
element, annotationType, annotationName, containerType, processor, new HashSet<AnnotatedElement>(), 0);
}
catch (Throwable ex) {
AnnotationUtils.rethrowAnnotationConfigurationException(ex);
@ -876,6 +998,8 @@ public class AnnotatedElementUtils { @@ -876,6 +998,8 @@ public class AnnotatedElementUtils {
* @param annotationType the annotation type to find
* @param annotationName the fully qualified class name of the annotation
* type to find (as an alternative to {@code annotationType})
* @param containerType the type of the container that holds repeatable
* annotations, or {@code null} if the annotation is not repeatable
* @param processor the processor to delegate to
* @param visited the set of annotated elements that have already been visited
* @param metaDepth the meta-depth of the annotation
@ -883,7 +1007,8 @@ public class AnnotatedElementUtils { @@ -883,7 +1007,8 @@ public class AnnotatedElementUtils {
* @since 4.2
*/
private static <T> T searchWithFindSemantics(AnnotatedElement element, Class<? extends Annotation> annotationType,
String annotationName, Processor<T> processor, Set<AnnotatedElement> visited, int metaDepth) {
String annotationName, Class<? extends Annotation> containerType, Processor<T> processor,
Set<AnnotatedElement> visited, int metaDepth) {
Assert.notNull(element, "AnnotatedElement must not be null");
Assert.hasLength(annotationName, "annotationName must not be null or empty");
@ -896,17 +1021,29 @@ public class AnnotatedElementUtils { @@ -896,17 +1021,29 @@ public class AnnotatedElementUtils {
// Search in local annotations
for (Annotation annotation : annotations) {
if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotation) &&
((annotationType != null ? annotation.annotationType() == annotationType :
annotation.annotationType().getName().equals(annotationName)) ||
metaDepth > 0)) {
T result = processor.process(element, annotation, metaDepth);
if (result != null) {
if (processor.aggregates() && metaDepth == 0) {
aggregatedResults.add(result);
if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotation)) {
if (annotation.annotationType() == annotationType
|| annotation.annotationType().getName().equals(annotationName)) {
T result = processor.process(element, annotation, metaDepth);
if (result != null) {
if (processor.aggregates() && metaDepth == 0) {
aggregatedResults.add(result);
}
else {
return result;
}
}
else {
return result;
}
// Repeatable annotations in container?
else if (annotation.annotationType() == containerType) {
for (Annotation contained : getRawAnnotationsFromContainer(element, annotation)) {
T result = processor.process(element, contained, metaDepth);
if (result != null) {
// No need to post-process since repeatable annotations within a
// container cannot be composed annotations.
aggregatedResults.add(result);
}
}
}
}
@ -915,8 +1052,8 @@ public class AnnotatedElementUtils { @@ -915,8 +1052,8 @@ public class AnnotatedElementUtils {
// Search in meta annotations on local annotations
for (Annotation annotation : annotations) {
if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotation)) {
T result = searchWithFindSemantics(
annotation.annotationType(), annotationType, annotationName, processor, visited, metaDepth + 1);
T result = searchWithFindSemantics(annotation.annotationType(), annotationType, annotationName,
containerType, processor, visited, metaDepth + 1);
if (result != null) {
processor.postProcess(annotation.annotationType(), annotation, result);
if (processor.aggregates() && metaDepth == 0) {
@ -930,6 +1067,7 @@ public class AnnotatedElementUtils { @@ -930,6 +1067,7 @@ public class AnnotatedElementUtils {
}
if (processor.aggregates()) {
// Prepend to support top-down ordering within class hierarchies
processor.getAggregatedResults().addAll(0, aggregatedResults);
}
@ -938,7 +1076,7 @@ public class AnnotatedElementUtils { @@ -938,7 +1076,7 @@ public class AnnotatedElementUtils {
// Search on possibly bridged method
Method resolvedMethod = BridgeMethodResolver.findBridgedMethod(method);
T result = searchWithFindSemantics(resolvedMethod, annotationType, annotationName,
T result = searchWithFindSemantics(resolvedMethod, annotationType, annotationName, containerType,
processor, visited, metaDepth);
if (result != null) {
return result;
@ -946,8 +1084,8 @@ public class AnnotatedElementUtils { @@ -946,8 +1084,8 @@ public class AnnotatedElementUtils {
// Search on methods in interfaces declared locally
Class<?>[] ifcs = method.getDeclaringClass().getInterfaces();
result = searchOnInterfaces(
method, annotationType, annotationName, processor, visited, metaDepth, ifcs);
result = searchOnInterfaces(method, annotationType, annotationName, containerType, processor,
visited, metaDepth, ifcs);
if (result != null) {
return result;
}
@ -964,7 +1102,7 @@ public class AnnotatedElementUtils { @@ -964,7 +1102,7 @@ public class AnnotatedElementUtils {
Method equivalentMethod = clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
Method resolvedEquivalentMethod = BridgeMethodResolver.findBridgedMethod(equivalentMethod);
result = searchWithFindSemantics(resolvedEquivalentMethod, annotationType, annotationName,
processor, visited, metaDepth);
containerType, processor, visited, metaDepth);
if (result != null) {
return result;
}
@ -974,8 +1112,8 @@ public class AnnotatedElementUtils { @@ -974,8 +1112,8 @@ public class AnnotatedElementUtils {
}
// Search on interfaces declared on superclass
result = searchOnInterfaces(method, annotationType, annotationName, processor, visited,
metaDepth, clazz.getInterfaces());
result = searchOnInterfaces(method, annotationType, annotationName, containerType, processor,
visited, metaDepth, clazz.getInterfaces());
if (result != null) {
return result;
}
@ -987,8 +1125,8 @@ public class AnnotatedElementUtils { @@ -987,8 +1125,8 @@ public class AnnotatedElementUtils {
// Search on interfaces
for (Class<?> ifc : clazz.getInterfaces()) {
T result = searchWithFindSemantics(
ifc, annotationType, annotationName, processor, visited, metaDepth);
T result = searchWithFindSemantics(ifc, annotationType, annotationName, containerType,
processor, visited, metaDepth);
if (result != null) {
return result;
}
@ -997,8 +1135,8 @@ public class AnnotatedElementUtils { @@ -997,8 +1135,8 @@ public class AnnotatedElementUtils {
// Search on superclass
Class<?> superclass = clazz.getSuperclass();
if (superclass != null && Object.class != superclass) {
T result = searchWithFindSemantics(
superclass, annotationType, annotationName, processor, visited, metaDepth);
T result = searchWithFindSemantics(superclass, annotationType, annotationName, containerType,
processor, visited, metaDepth);
if (result != null) {
return result;
}
@ -1012,14 +1150,15 @@ public class AnnotatedElementUtils { @@ -1012,14 +1150,15 @@ public class AnnotatedElementUtils {
return null;
}
private static <T> T searchOnInterfaces(Method method, Class<? extends Annotation> annotationType, String annotationName,
Processor<T> processor, Set<AnnotatedElement> visited, int metaDepth, Class<?>[] ifcs) {
private static <T> T searchOnInterfaces(Method method, Class<? extends Annotation> annotationType,
String annotationName, Class<? extends Annotation> containerType, Processor<T> processor,
Set<AnnotatedElement> visited, int metaDepth, Class<?>[] ifcs) {
for (Class<?> iface : ifcs) {
if (AnnotationUtils.isInterfaceWithAnnotatedMethods(iface)) {
try {
Method equivalentMethod = iface.getMethod(method.getName(), method.getParameterTypes());
T result = searchWithFindSemantics(equivalentMethod, annotationType, annotationName,
T result = searchWithFindSemantics(equivalentMethod, annotationType, annotationName, containerType,
processor, visited, metaDepth);
if (result != null) {
return result;
@ -1034,6 +1173,55 @@ public class AnnotatedElementUtils { @@ -1034,6 +1173,55 @@ public class AnnotatedElementUtils {
return null;
}
/**
* Get the array of raw (unsynthesized) annotations from the {@code value}
* attribute of the supplied repeatable annotation {@code container}.
* @since 4.3
*/
@SuppressWarnings("unchecked")
private static <A extends Annotation> A[] getRawAnnotationsFromContainer(AnnotatedElement element,
Annotation container) {
try {
return (A[]) AnnotationUtils.getValue(container);
}
catch (Exception ex) {
AnnotationUtils.handleIntrospectionFailure(element, ex);
}
// Unable to read value from repeating annotation container -> ignore it.
return (A[]) EMPTY_ANNOTATION_ARRAY;
}
/**
* Validate that the supplied {@code containerType} is a proper container
* annotation for the supplied repeatable {@code annotationType} (i.e.,
* that it declares a {@code value} attribute that holds an array of the
* {@code annotationType}).
* @since 4.3
* @throws AnnotationConfigurationException if the supplied {@code containerType}
* is not a valid container annotation for the supplied {@code annotationType}
*/
private static void validateRepeatableContainerType(Class<? extends Annotation> annotationType,
Class<? extends Annotation> containerType) {
try {
Method method = containerType.getDeclaredMethod(AnnotationUtils.VALUE);
Class<?> returnType = method.getReturnType();
if (!returnType.isArray() || returnType.getComponentType() != annotationType) {
String msg = String.format(
"Container type [%s] must declare a 'value' attribute for an array of type [%s]",
containerType.getName(), annotationType.getName());
throw new AnnotationConfigurationException(msg);
}
}
catch (Exception ex) {
AnnotationUtils.rethrowAnnotationConfigurationException(ex);
String msg = String.format("Invalid declaration of container type [%s] for repeatable annotation [%s]",
containerType.getName(), annotationType.getName());
throw new AnnotationConfigurationException(msg, ex);
}
}
/**
* Callback interface that is used to process annotations during a search.
@ -1114,10 +1302,10 @@ public class AnnotatedElementUtils { @@ -1114,10 +1302,10 @@ public class AnnotatedElementUtils {
/**
* Get the list of results aggregated by this processor.
* <p>NOTE: the processor does not aggregate the results itself.
* Rather, the search algorithm that uses this processor is responsible
* for asking this processor if it {@link #aggregates} results and then
* adding the post-processed results to the list returned by this
* <p>NOTE: the processor does <strong>not</strong> aggregate the results
* itself. Rather, the search algorithm that uses this processor is
* responsible for asking this processor if it {@link #aggregates} results
* and then adding the post-processed results to the list returned by this
* method.
* <p>WARNING: aggregation is currently only supported for <em>find semantics</em>.
* @return the list of results aggregated by this processor; never
@ -1158,6 +1346,8 @@ public class AnnotatedElementUtils { @@ -1158,6 +1346,8 @@ public class AnnotatedElementUtils {
* target annotation during the {@link #process} phase and then merges
* annotation attributes from lower levels in the annotation hierarchy
* during the {@link #postProcess} phase.
* <p>A {@code MergedAnnotationAttributesProcessor} may optionally be
* configured to {@linkplain #aggregates aggregate} results.
* @since 4.2
* @see AnnotationUtils#retrieveAnnotationAttributes
* @see AnnotationUtils#postProcessAnnotationAttributes
@ -1172,6 +1362,8 @@ public class AnnotatedElementUtils { @@ -1172,6 +1362,8 @@ public class AnnotatedElementUtils {
private final boolean nestedAnnotationsAsMap;
private final boolean aggregates;
private final List<AnnotationAttributes> aggregatedResults;
@ -1188,12 +1380,13 @@ public class AnnotatedElementUtils { @@ -1188,12 +1380,13 @@ public class AnnotatedElementUtils {
this.annotationName = annotationName;
this.classValuesAsString = classValuesAsString;
this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
this.aggregates = aggregates;
this.aggregatedResults = (aggregates ? new ArrayList<AnnotationAttributes>() : null);
}
@Override
public boolean aggregates() {
return this.aggregatedResults != null;
return this.aggregates;
}
@Override
@ -1232,7 +1425,7 @@ public class AnnotatedElementUtils { @@ -1232,7 +1425,7 @@ public class AnnotatedElementUtils {
targetAttributeNames.add(attributeOverrideName);
valuesAlreadyReplaced.add(attributeOverrideName);
// Ensure all aliased attributes in the target annotation are also overridden. (SPR-14069)
// Ensure all aliased attributes in the target annotation are overridden. (SPR-14069)
List<String> aliases = AnnotationUtils.getAttributeAliasMap(targetAnnotationType).get(attributeOverrideName);
if (aliases != null) {
for (String alias : aliases) {

41
spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java
Unescape View File

@ -111,6 +111,7 @@ public abstract class AnnotationUtils { @@ -111,6 +111,7 @@ public abstract class AnnotationUtils {
*/
public static final String VALUE = "value";
private static final String REPEATABLE_CLASS_NAME = "java.lang.annotation.Repeatable";
private static final Map<AnnotationCacheKey, Annotation> findAnnotationCache =
new ConcurrentReferenceHashMap<AnnotationCacheKey, Annotation>(256);
@ -1720,6 +1721,29 @@ public abstract class AnnotationUtils { @@ -1720,6 +1721,29 @@ public abstract class AnnotationUtils {
return (method != null && method.getName().equals("annotationType") && method.getParameterTypes().length == 0);
}
/**
* Resolve the container type for the supplied repeatable {@code annotationType}.
* <p>Automatically detects a <em>container annotation</em> declared via
* {@link java.lang.annotation.Repeatable}. If the supplied annotation type
* is not annotated with {@code @Repeatable}, this method simply returns
* {@code null}.
* @since 4.2
*/
@SuppressWarnings("unchecked")
static Class<? extends Annotation> resolveContainerAnnotationType(Class<? extends Annotation> annotationType) {
try {
Annotation repeatable = getAnnotation(annotationType, REPEATABLE_CLASS_NAME);
if (repeatable != null) {
Object value = AnnotationUtils.getValue(repeatable);
return (Class<? extends Annotation>) value;
}
}
catch (Exception ex) {
handleIntrospectionFailure(annotationType, ex);
}
return null;
}
/**
* <p>If the supplied throwable is an {@link AnnotationConfigurationException},
* it will be cast to an {@code AnnotationConfigurationException} and thrown,
@ -1806,8 +1830,6 @@ public abstract class AnnotationUtils { @@ -1806,8 +1830,6 @@ public abstract class AnnotationUtils {
private static class AnnotationCollector<A extends Annotation> {
private static final String REPEATABLE_CLASS_NAME = "java.lang.annotation.Repeatable";
private final Class<A> annotationType;
private final Class<? extends Annotation> containerAnnotationType;
@ -1825,21 +1847,6 @@ public abstract class AnnotationUtils { @@ -1825,21 +1847,6 @@ public abstract class AnnotationUtils {
this.declaredMode = declaredMode;
}
@SuppressWarnings("unchecked")
static Class<? extends Annotation> resolveContainerAnnotationType(Class<? extends Annotation> annotationType) {
try {
Annotation repeatable = getAnnotation(annotationType, REPEATABLE_CLASS_NAME);
if (repeatable != null) {
Object value = AnnotationUtils.getValue(repeatable);
return (Class<? extends Annotation>) value;
}
}
catch (Exception ex) {
handleIntrospectionFailure(annotationType, ex);
}
return null;
}
Set<A> getResult(AnnotatedElement element) {
process(element);
return Collections.unmodifiableSet(this.result);

230
spring-core/src/test/java/org/springframework/core/annotation/ComposedRepeatableAnnotationsTests.java
Unescape View File

@ -0,0 +1,230 @@ @@ -0,0 +1,230 @@
/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.AnnotatedElement;
import java.util.Iterator;
import java.util.Set;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.*;
import static org.springframework.core.annotation.AnnotatedElementUtils.*;
/**
* Unit tests that verify support for finding all composed, repeatable
* annotations on a single annotated element.
*
* <p>See <a href="https://jira.spring.io/browse/SPR-13973">SPR-13973</a>.
*
* @author Sam Brannen
* @since 4.3
* @see AnnotatedElementUtils
* @see AnnotatedElementUtilsTests
*/
public class ComposedRepeatableAnnotationsTests {
@Rule
public final ExpectedException exception = ExpectedException.none();
@Test
public void nonRepeatableAnnotation() {
exception.expect(IllegalArgumentException.class);
exception.expectMessage(startsWith("annotationType must be a repeatable annotation"));
exception.expectMessage(containsString("failed to resolve container type for"));
exception.expectMessage(containsString(NonRepeatable.class.getName()));
findMergedRepeatableAnnotations(getClass(), NonRepeatable.class);
}
@Test
public void invalidRepeatableAnnotationContainerMissingValueAttribute() {
exception.expect(AnnotationConfigurationException.class);
exception.expectMessage(startsWith("Invalid declaration of container type"));
exception.expectMessage(containsString(ContainerMissingValueAttribute.class.getName()));
exception.expectMessage(containsString("for repeatable annotation"));
exception.expectMessage(containsString(InvalidRepeatable.class.getName()));
exception.expectCause(isA(NoSuchMethodException.class));
findMergedRepeatableAnnotations(getClass(), InvalidRepeatable.class, ContainerMissingValueAttribute.class);
}
@Test
public void invalidRepeatableAnnotationContainerWithNonArrayValueAttribute() {
exception.expect(AnnotationConfigurationException.class);
exception.expectMessage(startsWith("Container type"));
exception.expectMessage(containsString(ContainerWithNonArrayValueAttribute.class.getName()));
exception.expectMessage(containsString("must declare a 'value' attribute for an array of type"));
exception.expectMessage(containsString(InvalidRepeatable.class.getName()));
findMergedRepeatableAnnotations(getClass(), InvalidRepeatable.class, ContainerWithNonArrayValueAttribute.class);
}
@Test
public void invalidRepeatableAnnotationContainerWithArrayValueAttributeButWrongComponentType() {
exception.expect(AnnotationConfigurationException.class);
exception.expectMessage(startsWith("Container type"));
exception.expectMessage(containsString(ContainerWithArrayValueAttributeButWrongComponentType.class.getName()));
exception.expectMessage(containsString("must declare a 'value' attribute for an array of type"));
exception.expectMessage(containsString(InvalidRepeatable.class.getName()));
findMergedRepeatableAnnotations(getClass(), InvalidRepeatable.class,
ContainerWithArrayValueAttributeButWrongComponentType.class);
}
@Test
public void repeatableAnnotationsOnClass() {
assertRepeatableAnnotations(RepeatableClass.class);
}
@Test
public void repeatableAnnotationsOnSuperclass() {
assertRepeatableAnnotations(SubRepeatableClass.class);
}
@Test
public void composedRepeatableAnnotationsOnClass() {
assertRepeatableAnnotations(ComposedRepeatableClass.class);
}
@Test
public void composedRepeatableAnnotationsMixedWithContainerOnClass() {
assertRepeatableAnnotations(ComposedRepeatableMixedWithContainerClass.class);
}
@Test
public void composedContainerForRepeatableAnnotationsOnClass() {
assertRepeatableAnnotations(ComposedContainerClass.class);
}
private void assertRepeatableAnnotations(AnnotatedElement element) {
assertNotNull(element);
Set<PeteRepeat> peteRepeats = findMergedRepeatableAnnotations(element, PeteRepeat.class);
assertNotNull(peteRepeats);
assertEquals(3, peteRepeats.size());
Iterator<PeteRepeat> iterator = peteRepeats.iterator();
assertEquals("A", iterator.next().value());
assertEquals("B", iterator.next().value());
assertEquals("C", iterator.next().value());
}
// -------------------------------------------------------------------------
@Retention(RetentionPolicy.RUNTIME)
@interface NonRepeatable {
}
@Retention(RetentionPolicy.RUNTIME)
@interface ContainerMissingValueAttribute {
// InvalidRepeatable[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@interface ContainerWithNonArrayValueAttribute {
InvalidRepeatable value();
}
@Retention(RetentionPolicy.RUNTIME)
@interface ContainerWithArrayValueAttributeButWrongComponentType {
String[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@interface InvalidRepeatable {
}
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface PeteRepeats {
PeteRepeat[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Repeatable(PeteRepeats.class)
@interface PeteRepeat {
String value();
}
@PeteRepeat("shadowed")
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface ForPetesSake {
@AliasFor(annotation = PeteRepeat.class)
String value();
}
@PeteRepeat("shadowed")
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface ForTheLoveOfFoo {
@AliasFor(annotation = PeteRepeat.class)
String value();
}
@PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") })
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface ComposedContainer {
}
@PeteRepeat("A")
@PeteRepeats({ @PeteRepeat("B"), @PeteRepeat("C") })
static class RepeatableClass {
}
static class SubRepeatableClass extends RepeatableClass {
}
@ForPetesSake("B")
@ForTheLoveOfFoo("C")
@PeteRepeat("A")
static class ComposedRepeatableClass {
}
@ForPetesSake("C")
@PeteRepeats(@PeteRepeat("A"))
@PeteRepeat("B")
static class ComposedRepeatableMixedWithContainerClass {
}
@PeteRepeat("A")
@ComposedContainer
static class ComposedContainerClass {
}
}
Write Preview
Loading…
Cancel
Save