TypeDescriptor supports merged annotation lookups (for composable formatting annotations)

Issue: SPR-14844

Author: jhoeller

spring-context/src/test/java/org/springframework/format/support/FormattingConversionServiceFactoryBeanTests.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.format.support;
 
 import java.lang.annotation.ElementType;
@@ -27,6 +28,7 @@
 import org.junit.Test;
 
 import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.core.annotation.AliasFor;
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.format.AnnotationFormatterFactory;
@@ -132,9 +134,15 @@ public void testInvalidFormatter() throws Exception {
 	}
 
 
-	@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER })
+	@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
 	@Retention(RetentionPolicy.RUNTIME)
 	private @interface SpecialInt {
+
+		@AliasFor("alias")
+		String value() default "";
+
+		@AliasFor("value")
+		String alias() default "";
 	}
 
 
@@ -143,7 +151,7 @@ private static class TestBean {
 		@NumberFormat(pattern = "##,00")
 		private double pattern;
 
-		@SpecialInt
+		@SpecialInt("aliased")
 		private int specialInt;
 
 		public int getSpecialInt() {
@@ -187,6 +195,8 @@ public Set<Class<?>> getFieldTypes() {
 
 		@Override
 		public Printer<?> getPrinter(SpecialInt annotation, Class<?> fieldType) {
+			assertEquals("aliased", annotation.value());
+			assertEquals("aliased", annotation.alias());
 			return new Printer<Integer>() {
 				@Override
 				public String print(Integer object, Locale locale) {
@@ -197,6 +207,8 @@ public String print(Integer object, Locale locale) {
 
 		@Override
 		public Parser<?> getParser(SpecialInt annotation, Class<?> fieldType) {
+			assertEquals("aliased", annotation.value());
+			assertEquals("aliased", annotation.alias());
 			return new Parser<Integer>() {
 				@Override
 				public Integer parse(String text, Locale locale) throws ParseException {

spring-core/src/main/java/org/springframework/core/convert/TypeDescriptor.java

@@ -18,16 +18,18 @@
 
 import java.io.Serializable;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Field;
 import java.lang.reflect.Type;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Stream;
 
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ResolvableType;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;
@@ -66,7 +68,7 @@ public class TypeDescriptor implements Serializable {
 
 	private final ResolvableType resolvableType;
 
-	private final Annotation[] annotations;
+	private final AnnotatedElement annotatedElement;
 
 
 	/**
@@ -79,9 +81,8 @@ public TypeDescriptor(MethodParameter methodParameter) {
 		Assert.notNull(methodParameter, "MethodParameter must not be null");
 		this.resolvableType = ResolvableType.forMethodParameter(methodParameter);
 		this.type = this.resolvableType.resolve(methodParameter.getParameterType());
-		this.annotations = (methodParameter.getParameterIndex() == -1 ?
-				nullSafeAnnotations(methodParameter.getMethodAnnotations()) :
-				nullSafeAnnotations(methodParameter.getParameterAnnotations()));
+		this.annotatedElement = new AnnotatedElementAdapter(methodParameter.getParameterIndex() == -1 ?
+				methodParameter.getMethodAnnotations() : methodParameter.getParameterAnnotations());
 	}
 
 	/**
@@ -93,7 +94,7 @@ public TypeDescriptor(Field field) {
 		Assert.notNull(field, "Field must not be null");
 		this.resolvableType = ResolvableType.forField(field);
 		this.type = this.resolvableType.resolve(field.getType());
-		this.annotations = nullSafeAnnotations(field.getAnnotations());
+		this.annotatedElement = new AnnotatedElementAdapter(field.getAnnotations());
 	}
 
 	/**
@@ -106,7 +107,7 @@ public TypeDescriptor(Property property) {
 		Assert.notNull(property, "Property must not be null");
 		this.resolvableType = ResolvableType.forMethodParameter(property.getMethodParameter());
 		this.type = this.resolvableType.resolve(property.getType());
-		this.annotations = nullSafeAnnotations(property.getAnnotations());
+		this.annotatedElement = new AnnotatedElementAdapter(property.getAnnotations());
 	}
 
 	/**
@@ -120,14 +121,10 @@ public TypeDescriptor(Property property) {
 	protected TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations) {
 		this.resolvableType = resolvableType;
 		this.type = (type != null ? type : resolvableType.resolve(Object.class));
-		this.annotations = nullSafeAnnotations(annotations);
+		this.annotatedElement = new AnnotatedElementAdapter(annotations);
 	}
 
 
-	private Annotation[] nullSafeAnnotations(Annotation[] annotations) {
-		return (annotations != null ? annotations : EMPTY_ANNOTATION_ARRAY);
-	}
-
 	/**
 	 * Variation of {@link #getType()} that accounts for a primitive type by
 	 * returning its object wrapper type.
@@ -189,8 +186,8 @@ public TypeDescriptor narrow(Object value) {
 		if (value == null) {
 			return this;
 		}
-		ResolvableType narrowed = ResolvableType.forType(value.getClass(), this.resolvableType);
-		return new TypeDescriptor(narrowed, null, this.annotations);
+		ResolvableType narrowed = ResolvableType.forType(value.getClass(), getResolvableType());
+		return new TypeDescriptor(narrowed, null, getAnnotations());
 	}
 
 	/**
@@ -206,7 +203,7 @@ public TypeDescriptor upcast(Class<?> superType) {
 			return null;
 		}
 		Assert.isAssignable(superType, getType());
-		return new TypeDescriptor(this.resolvableType.as(superType), superType, this.annotations);
+		return new TypeDescriptor(getResolvableType().as(superType), superType, getAnnotations());
 	}
 
 	/**
@@ -228,7 +225,7 @@ public boolean isPrimitive() {
 	 * @return the annotations, or an empty array if none
 	 */
 	public Annotation[] getAnnotations() {
-		return this.annotations;
+		return this.annotatedElement.getAnnotations();
 	}
 
 	/**
@@ -239,7 +236,7 @@ public Annotation[] getAnnotations() {
 	 * @return <tt>true</tt> if the annotation is present
 	 */
 	public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
-		return (getAnnotation(annotationType) != null);
+		return AnnotatedElementUtils.isAnnotated(this.annotatedElement, annotationType);
 	}
 
 	/**
@@ -250,22 +247,7 @@ public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
 	 */
 	@SuppressWarnings("unchecked")
 	public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
-		// Search in annotations that are "present" (i.e., locally declared or inherited)
-		// NOTE: this unfortunately favors inherited annotations over locally declared composed annotations.
-		for (Annotation annotation : getAnnotations()) {
-			if (annotation.annotationType() == annotationType) {
-				return (T) annotation;
-			}
-		}
-
-		// Search in annotation hierarchy
-		for (Annotation composedAnnotation : getAnnotations()) {
-			T ann = AnnotationUtils.findAnnotation(composedAnnotation.annotationType(), annotationType);
-			if (ann != null) {
-				return ann;
-			}
-		}
-		return null;
+		return AnnotatedElementUtils.getMergedAnnotation(this.annotatedElement, annotationType);
 	}
 
 	/**
@@ -333,13 +315,13 @@ public boolean isArray() {
 	 * @throws IllegalStateException if this type is not a {@code java.util.Collection} or array type
 	 */
 	public TypeDescriptor getElementTypeDescriptor() {
-		if (this.resolvableType.isArray()) {
-			return new TypeDescriptor(this.resolvableType.getComponentType(), null, this.annotations);
+		if (getResolvableType().isArray()) {
+			return new TypeDescriptor(getResolvableType().getComponentType(), null, getAnnotations());
 		}
-		if (Stream.class.isAssignableFrom(this.type)) {
-			return getRelatedIfResolvable(this, this.resolvableType.as(Stream.class).getGeneric(0));
+		if (Stream.class.isAssignableFrom(getType())) {
+			return getRelatedIfResolvable(this, getResolvableType().as(Stream.class).getGeneric(0));
 		}
-		return getRelatedIfResolvable(this, this.resolvableType.asCollection().getGeneric(0));
+		return getRelatedIfResolvable(this, getResolvableType().asCollection().getGeneric(0));
 	}
 
 	/**
@@ -380,8 +362,8 @@ public boolean isMap() {
 	 * @throws IllegalStateException if this type is not a {@code java.util.Map}
 	 */
 	public TypeDescriptor getMapKeyTypeDescriptor() {
-		Assert.state(isMap(), "Not a java.util.Map");
-		return getRelatedIfResolvable(this, this.resolvableType.asMap().getGeneric(0));
+		Assert.state(isMap(), "Not a [java.util.Map]");
+		return getRelatedIfResolvable(this, getResolvableType().asMap().getGeneric(0));
 	}
 
 	/**
@@ -415,8 +397,8 @@ public TypeDescriptor getMapKeyTypeDescriptor(Object mapKey) {
 	 * @throws IllegalStateException if this type is not a {@code java.util.Map}
 	 */
 	public TypeDescriptor getMapValueTypeDescriptor() {
-		Assert.state(isMap(), "Not a java.util.Map");
-		return getRelatedIfResolvable(this, this.resolvableType.asMap().getGeneric(1));
+		Assert.state(isMap(), "Not a [java.util.Map]");
+		return getRelatedIfResolvable(this, getResolvableType().asMap().getGeneric(1));
 	}
 
 	/**
@@ -444,7 +426,7 @@ private TypeDescriptor narrow(Object value, TypeDescriptor typeDescriptor) {
 		if (typeDescriptor != null) {
 			return typeDescriptor.narrow(value);
 		}
-		return (value != null ? new TypeDescriptor(this.resolvableType, value.getClass(), this.annotations) : null);
+		return (value != null ? new TypeDescriptor(getResolvableType(), value.getClass(), getAnnotations()) : null);
 	}
 
 	@Override
@@ -490,7 +472,7 @@ public String toString() {
 		for (Annotation ann : getAnnotations()) {
 			builder.append("@").append(ann.annotationType().getName()).append(' ');
 		}
-		builder.append(this.resolvableType.toString());
+		builder.append(getResolvableType().toString());
 		return builder.toString();
 	}
 
@@ -525,9 +507,9 @@ public static TypeDescriptor valueOf(Class<?> type) {
 	 * @return the collection type descriptor
 	 */
 	public static TypeDescriptor collection(Class<?> collectionType, TypeDescriptor elementTypeDescriptor) {
-		Assert.notNull(collectionType, "collectionType must not be null");
+		Assert.notNull(collectionType, "Collection type must not be null");
 		if (!Collection.class.isAssignableFrom(collectionType)) {
-			throw new IllegalArgumentException("collectionType must be a java.util.Collection");
+			throw new IllegalArgumentException("Collection type must be a [java.util.Collection]");
 		}
 		ResolvableType element = (elementTypeDescriptor != null ? elementTypeDescriptor.resolvableType : null);
 		return new TypeDescriptor(ResolvableType.forClassWithGenerics(collectionType, element), null, null);
@@ -548,8 +530,9 @@ public static TypeDescriptor collection(Class<?> collectionType, TypeDescriptor
 	 * @return the map type descriptor
 	 */
 	public static TypeDescriptor map(Class<?> mapType, TypeDescriptor keyTypeDescriptor, TypeDescriptor valueTypeDescriptor) {
+		Assert.notNull(mapType, "Map type must not be null");
 		if (!Map.class.isAssignableFrom(mapType)) {
-			throw new IllegalArgumentException("mapType must be a java.util.Map");
+			throw new IllegalArgumentException("Map type must be a [java.util.Map]");
 		}
 		ResolvableType key = (keyTypeDescriptor != null ? keyTypeDescriptor.resolvableType : null);
 		ResolvableType value = (valueTypeDescriptor != null ? valueTypeDescriptor.resolvableType : null);
@@ -687,7 +670,60 @@ private static TypeDescriptor getRelatedIfResolvable(TypeDescriptor source, Reso
 		if (type.resolve() == null) {
 			return null;
 		}
-		return new TypeDescriptor(type, null, source.annotations);
+		return new TypeDescriptor(type, null, source.getAnnotations());
+	}
+
+
+	/**
+	 * Adapter class for exposing a {@code TypeDescriptor}'s annotations as an
+	 * {@link AnnotatedElement}, in particular to {@link AnnotatedElementUtils}.
+	 * @see AnnotatedElementUtils#isAnnotated(AnnotatedElement, Class)
+	 * @see AnnotatedElementUtils#getMergedAnnotation(AnnotatedElement, Class)
+	 */
+	private class AnnotatedElementAdapter implements AnnotatedElement, Serializable {
+
+		private final Annotation[] annotations;
+
+		public AnnotatedElementAdapter(Annotation[] annotations) {
+			this.annotations = annotations;
+		}
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+			for (Annotation annotation : getAnnotations()) {
+				if (annotation.annotationType() == annotationClass) {
+					return (T) annotation;
+				}
+			}
+			return null;
+		}
+
+		@Override
+		public Annotation[] getAnnotations() {
+			return (this.annotations != null ? this.annotations : EMPTY_ANNOTATION_ARRAY);
+		}
+
+		@Override
+		public Annotation[] getDeclaredAnnotations() {
+			return getAnnotations();
+		}
+
+		@Override
+		public boolean equals(Object other) {
+			return (this == other || (other instanceof AnnotatedElementAdapter &&
+					Arrays.equals(this.annotations, ((AnnotatedElementAdapter) other).annotations)));
+		}
+
+		@Override
+		public int hashCode() {
+			return Arrays.hashCode(this.annotations);
+		}
+
+		@Override
+		public String toString() {
+			return TypeDescriptor.this.toString();
+		}
 	}
 
 }