Support abstract, bridge, & interface methods in AnnotatedElementUtils

This commit introduces support for finding annotations on abstract,
bridge, and interface methods in AnnotatedElementUtils.

 - Introduced dedicated findAnnotationAttributes() methods in
   AnnotatedElementUtils that provide first-class support for
   processing methods, class hierarchies, interfaces, bridge methods,
   etc.

 - Introduced find/get search algorithm dichotomy in
   AnnotatedElementUtils which is visible in the public API as well as
   in the internal implementation. This was necessary in order to
   maintain backwards compatibility with the existing API (even though
   it was undocumented).

 - Reverted all recent changes made to the "get semantics" search
   algorithm in AnnotatedElementUtils in order to ensure backwards
   compatibility, and reverted recent changes to
   JtaTransactionAnnotationParser and SpringTransactionAnnotationParser
   accordingly.

 - Documented internal AnnotatedElementUtils.Processor<T> interface.

 - Enabled failing tests and introduced
   findAnnotationAttributesFromBridgeMethod() test in
   AnnotatedElementUtilsTests.

 - Refactored ApplicationListenerMethodAdapter.getCondition() and
   enabled failing test in TransactionalEventListenerTests.

 - AnnotationUtils.isInterfaceWithAnnotatedMethods() is now package
   private.

Issue: SPR-12738, SPR-11514, SPR-11598

Author: sbrannen

spring-context/src/main/java/org/springframework/context/event/ApplicationListenerMethodAdapter.java

@@ -162,7 +162,6 @@ private void publishEvent(Object event) {
 		}
 	}
 
-
 	private boolean shouldHandle(ApplicationEvent event, Object[] args) {
 		if (args == null) {
 			return false;
@@ -250,16 +249,11 @@ protected Object getTargetBean() {
 	protected String getCondition() {
 		if (this.condition == null) {
 			AnnotationAttributes annotationAttributes = AnnotatedElementUtils
-					.getAnnotationAttributes(this.method, EventListener.class.getName());
+					.findAnnotationAttributes(this.method, EventListener.class);
 			if (annotationAttributes != null) {
 				String value = annotationAttributes.getString("condition");
 				this.condition = (value != null ? value : "");
 			}
-			// TODO [SPR-12738] Remove once AnnotatedElementUtils finds annotated methods on interfaces (e.g., in dynamic proxies)
-			else {
-				EventListener eventListener = getMethodAnnotation(EventListener.class);
-				this.condition = (eventListener != null ? eventListener.condition() : "");
-			}
 		}
 		return this.condition;
 	}

spring-core/src/main/java/org/springframework/core/annotation/AnnotatedElementUtils.java

@@ -100,9 +100,9 @@ public abstract class AnnotationUtils {
 	 * @since 4.0
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T extends Annotation> T getAnnotation(Annotation ann, Class<T> annotationType) {
+	public static <A extends Annotation> A getAnnotation(Annotation ann, Class<A> annotationType) {
 		if (annotationType.isInstance(ann)) {
-			return (T) ann;
+			return (A) ann;
 		}
 		try {
 			return ann.annotationType().getAnnotation(annotationType);
@@ -126,9 +126,9 @@ public static <T extends Annotation> T getAnnotation(Annotation ann, Class<T> an
 	 * @return the matching annotation, or {@code null} if not found
 	 * @since 3.1
 	 */
-	public static <T extends Annotation> T getAnnotation(AnnotatedElement annotatedElement, Class<T> annotationType) {
+	public static <A extends Annotation> A getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType) {
 		try {
-			T ann = annotatedElement.getAnnotation(annotationType);
+			A ann = annotatedElement.getAnnotation(annotationType);
 			if (ann == null) {
 				for (Annotation metaAnn : annotatedElement.getAnnotations()) {
 					ann = metaAnn.annotationType().getAnnotation(annotationType);
@@ -294,18 +294,18 @@ public static <A extends Annotation> A findAnnotation(AnnotatedElement annotated
 	 * @since 4.2
 	 */
 	@SuppressWarnings("unchecked")
-	private static <T extends Annotation> T findAnnotation(AnnotatedElement annotatedElement, Class<T> annotationType, Set<Annotation> visited) {
+	private static <A extends Annotation> A findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType, Set<Annotation> visited) {
 		Assert.notNull(annotatedElement, "AnnotatedElement must not be null");
 		try {
 			Annotation[] anns = annotatedElement.getDeclaredAnnotations();
 			for (Annotation ann : anns) {
 				if (ann.annotationType().equals(annotationType)) {
-					return (T) ann;
+					return (A) ann;
 				}
 			}
 			for (Annotation ann : anns) {
 				if (!isInJavaLangAnnotationPackage(ann) && visited.add(ann)) {
-					T annotation = findAnnotation((AnnotatedElement) ann.annotationType(), annotationType, visited);
+					A annotation = findAnnotation((AnnotatedElement) ann.annotationType(), annotationType, visited);
 					if (annotation != null) {
 						return annotation;
 					}
@@ -392,16 +392,16 @@ private static <A extends Annotation> A searchOnInterfaces(Method method, Class<
 		return annotation;
 	}
 
-	private static boolean isInterfaceWithAnnotatedMethods(Class<?> iface) {
+	static boolean isInterfaceWithAnnotatedMethods(Class<?> iface) {
 		Boolean flag = annotatedInterfaceCache.get(iface);
 		if (flag != null) {
-			return flag;
+			return flag.booleanValue();
 		}
-		boolean found = false;
+		Boolean found = Boolean.FALSE;
 		for (Method ifcMethod : iface.getMethods()) {
 			try {
 				if (ifcMethod.getAnnotations().length > 0) {
-					found = true;
+					found = Boolean.TRUE;
 					break;
 				}
 			}
@@ -411,7 +411,7 @@ private static boolean isInterfaceWithAnnotatedMethods(Class<?> iface) {
 			}
 		}
 		annotatedInterfaceCache.put(iface, found);
-		return found;
+		return found.booleanValue();
 	}
 
 	/**

spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java

@@ -126,94 +126,135 @@ public void getAnnotationAttributesFavorsInheritedComposedAnnotationsOverMoreLoc
 			attributes.getBoolean("readOnly"));
 	}
 
+	// TODO [SPR-11598] Enable test.
+	@Ignore("Disabled until SPR-11598 is resolved")
+	@Test
+	public void getAnnotationAttributesFromInterfaceImplementedBySuperclass() {
+		String name = Transactional.class.getName();
+		AnnotationAttributes attributes = getAnnotationAttributes(ConcreteClassWithInheritedAnnotation.class, name);
+		assertNotNull("Should find @Transactional on ConcreteClassWithInheritedAnnotation", attributes);
+	}
+
 	/** @since 4.2 */
 	@Test
 	public void getAnnotationAttributesOnInheritedAnnotationInterface() {
 		String name = Transactional.class.getName();
 		AnnotationAttributes attributes = getAnnotationAttributes(InheritedAnnotationInterface.class, name);
+		assertNotNull("Should get @Transactional on InheritedAnnotationInterface", attributes);
+	}
+
+	/** @since 4.2 */
+	@Test
+	public void findAnnotationAttributesOnInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(InheritedAnnotationInterface.class, Transactional.class);
 		assertNotNull("Should find @Transactional on InheritedAnnotationInterface", attributes);
 	}
 
 	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesOnSubInheritedAnnotationInterface() {
-		String name = Transactional.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(SubInheritedAnnotationInterface.class, name);
+	public void findAnnotationAttributesOnSubInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(SubInheritedAnnotationInterface.class, Transactional.class);
 		assertNotNull("Should find @Transactional on SubInheritedAnnotationInterface", attributes);
 	}
 
 	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesOnSubSubInheritedAnnotationInterface() {
-		String name = Transactional.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(SubSubInheritedAnnotationInterface.class, name);
+	public void findAnnotationAttributesOnSubSubInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(SubSubInheritedAnnotationInterface.class, Transactional.class);
 		assertNotNull("Should find @Transactional on SubSubInheritedAnnotationInterface", attributes);
 	}
 
 	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesOnNonInheritedAnnotationInterface() {
-		String name = Order.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(NonInheritedAnnotationInterface.class, name);
+	public void findAnnotationAttributesOnNonInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(NonInheritedAnnotationInterface.class, Order.class);
 		assertNotNull("Should find @Order on NonInheritedAnnotationInterface", attributes);
 	}
 
 	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesOnSubNonInheritedAnnotationInterface() {
-		String name = Order.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(SubNonInheritedAnnotationInterface.class, name);
-		assertNotNull("Should find @Order on SubNonInheritedAnnotationInterface", attributes);
+	public void getAnnotationAttributesOnNonInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = getAnnotationAttributes(NonInheritedAnnotationInterface.class, Order.class.getName());
+		assertNotNull("Should get @Order on NonInheritedAnnotationInterface", attributes);
 	}
 
 	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesOnSubSubNonInheritedAnnotationInterface() {
-		String name = Order.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(SubSubNonInheritedAnnotationInterface.class, name);
-		assertNotNull("Should find @Order on SubSubNonInheritedAnnotationInterface", attributes);
+	public void findAnnotationAttributesOnSubNonInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(SubNonInheritedAnnotationInterface.class, Order.class);
+		assertNotNull("Should find @Order on SubNonInheritedAnnotationInterface", attributes);
 	}
 
-	// TODO [SPR-11598] Enable test.
-	@Ignore("Disabled until SPR-11598 is resolved")
+	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesFromInterfaceImplementedBySuperclass() {
-		String name = Transactional.class.getName();
-		AnnotationAttributes attributes = getAnnotationAttributes(ConcreteClassWithInheritedAnnotation.class, name);
-		assertNotNull("Should find @Transactional on ConcreteClassWithInheritedAnnotation", attributes);
+	public void findAnnotationAttributesOnSubSubNonInheritedAnnotationInterface() {
+		AnnotationAttributes attributes = findAnnotationAttributes(SubSubNonInheritedAnnotationInterface.class, Order.class);
+		assertNotNull("Should find @Order on SubSubNonInheritedAnnotationInterface", attributes);
 	}
 
-	// TODO [SPR-12738] Enable test.
-	@Ignore("Disabled until SPR-12738 is resolved")
+	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesInheritedFromInterfaceMethod() throws NoSuchMethodException {
-		String name = Order.class.getName();
+	public void findAnnotationAttributesInheritedFromInterfaceMethod() throws NoSuchMethodException {
 		Method method = ConcreteClassWithInheritedAnnotation.class.getMethod("handleFromInterface");
-		AnnotationAttributes attributes = getAnnotationAttributes(method, name);
-		assertNotNull("Should find @Order on ConcreteClassWithInheritedAnnotation.handleFromInterface() method",
-			attributes);
+		AnnotationAttributes attributes = findAnnotationAttributes(method, Order.class);
+		assertNotNull("Should find @Order on ConcreteClassWithInheritedAnnotation.handleFromInterface() method", attributes);
 	}
 
-	// TODO [SPR-12738] Enable test.
-	@Ignore("Disabled until SPR-12738 is resolved")
+	/** @since 4.2 */
 	@Test
-	public void getAnnotationAttributesInheritedFromAbstractMethod() throws NoSuchMethodException {
-		String name = Transactional.class.getName();
+	public void findAnnotationAttributesInheritedFromAbstractMethod() throws NoSuchMethodException {
 		Method method = ConcreteClassWithInheritedAnnotation.class.getMethod("handle");
-		AnnotationAttributes attributes = getAnnotationAttributes(method, name);
+		AnnotationAttributes attributes = findAnnotationAttributes(method, Transactional.class);
 		assertNotNull("Should find @Transactional on ConcreteClassWithInheritedAnnotation.handle() method", attributes);
 	}
 
-	// TODO [SPR-12738] Enable test.
+	/**
+	 * TODO [SPR-12738] Enable test.
+	 *
+	 * <p>{@code AbstractClassWithInheritedAnnotation} declares {@code handleParameterized(T)}; whereas,
+	 * {@code ConcreteClassWithInheritedAnnotation} declares {@code handleParameterized(String)}.
+	 *
+	 * <p>Thus, this test fails because {@code AnnotatedElementUtils.processWithFindSemantics()}
+	 * does not resolve an equivalent method for {@code handleParameterized(String)}
+	 * in {@code AbstractClassWithInheritedAnnotation}.
+	 *
+	 * @since 4.2
+	 */
 	@Ignore("Disabled until SPR-12738 is resolved")
 	@Test
-	public void getAnnotationAttributesInheritedFromParameterizedMethod() throws NoSuchMethodException {
-		String name = Transactional.class.getName();
+	public void findAnnotationAttributesInheritedFromBridgedMethod() throws NoSuchMethodException {
 		Method method = ConcreteClassWithInheritedAnnotation.class.getMethod("handleParameterized", String.class);
-		AnnotationAttributes attributes = getAnnotationAttributes(method, name);
+		AnnotationAttributes attributes = findAnnotationAttributes(method, Transactional.class);
 		assertNotNull("Should find @Transactional on ConcreteClassWithInheritedAnnotation.handleParameterized() method", attributes);
 	}
 
+	/**
+	 * Bridge/bridged method setup code copied from
+	 * {@link org.springframework.core.BridgeMethodResolverTests#testWithGenericParameter()}.
+	 * @since 4.2
+	 */
+	@Test
+	public void findAnnotationAttributesFromBridgeMethod() throws NoSuchMethodException {
+		Method[] methods = StringGenericParameter.class.getMethods();
+		Method bridgeMethod = null;
+		Method bridgedMethod = null;
+		for (Method method : methods) {
+			if ("getFor".equals(method.getName()) && !method.getParameterTypes()[0].equals(Integer.class)) {
+				if (method.getReturnType().equals(Object.class)) {
+					bridgeMethod = method;
+				}
+				else {
+					bridgedMethod = method;
+				}
+			}
+		}
+		assertTrue(bridgeMethod != null && bridgeMethod.isBridge());
+		assertTrue(bridgedMethod != null && !bridgedMethod.isBridge());
+
+		AnnotationAttributes attributes = findAnnotationAttributes(bridgeMethod, Order.class);
+		assertNotNull("Should find @Order on StringGenericParameter.getFor() method", attributes);
+	}
+
 
 	// -------------------------------------------------------------------------
 
@@ -349,6 +390,26 @@ public void handleFromInterface() {
 		}
 	}
 
+	public static interface GenericParameter<T> {
+
+		T getFor(Class<T> cls);
+	}
+
+	@SuppressWarnings("unused")
+	private static class StringGenericParameter implements GenericParameter<String> {
+
+		@Order
+		@Override
+		public String getFor(Class<String> cls) {
+			return "foo";
+		}
+
+		public String getFor(Integer integer) {
+			return "foo";
+		}
+	}
+
+
 	@Transactional
 	public static interface InheritedAnnotationInterface {
 	}

spring-core/src/test/java/org/springframework/core/annotation/AnnotatedElementUtilsTests.java

@@ -286,8 +286,8 @@ public AnnotationDescriptor(Class<?> rootDeclaringClass, Class<?> declaringClass
 			this.declaringClass = declaringClass;
 			this.composedAnnotation = composedAnnotation;
 			this.annotation = annotation;
-			this.annotationAttributes = AnnotatedElementUtils.getAnnotationAttributes(rootDeclaringClass,
-				annotation.annotationType().getName(), true, true, false, false);
+			this.annotationAttributes = AnnotatedElementUtils.findAnnotationAttributes(
+					rootDeclaringClass, annotation.annotationType());
 		}
 
 		public Class<?> getRootDeclaringClass() {

spring-test/src/main/java/org/springframework/test/util/MetaAnnotationUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -32,16 +32,14 @@
  * Strategy implementation for parsing JTA 1.2's {@link javax.transaction.Transactional} annotation.
  *
  * @author Juergen Hoeller
- * @author Sam Brannen
  * @since 4.0
  */
 @SuppressWarnings("serial")
 public class JtaTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
 
 	@Override
 	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
-		AnnotationAttributes ann = AnnotatedElementUtils.getAnnotationAttributes(ae,
-			javax.transaction.Transactional.class.getName(), false, false, false, false);
+		AnnotationAttributes ann = AnnotatedElementUtils.getAnnotationAttributes(ae, javax.transaction.Transactional.class.getName());
 		if (ann != null) {
 			return parseTransactionAnnotation(ann);
 		}

spring-tx/src/main/java/org/springframework/transaction/annotation/JtaTransactionAnnotationParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -32,16 +32,14 @@
  * Strategy implementation for parsing Spring's {@link Transactional} annotation.
  *
  * @author Juergen Hoeller
- * @author Sam Brannen
  * @since 2.5
  */
 @SuppressWarnings("serial")
 public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
 
 	@Override
 	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
-		AnnotationAttributes ann = AnnotatedElementUtils.getAnnotationAttributes(ae, Transactional.class.getName(),
-			false, false, false, false);
+		AnnotationAttributes ann = AnnotatedElementUtils.getAnnotationAttributes(ae, Transactional.class.getName());
 		if (ann != null) {
 			return parseTransactionAnnotation(ann);
 		}