Consistent use of AnnotatedElementUtils.findMergedAnnotation/hasAnnotation

Issue: SPR-13440

Author: jhoeller

spring-aspects/src/main/java/org/springframework/scheduling/aspectj/AnnotationAsyncExecutionAspect.aj

@@ -19,7 +19,7 @@ package org.springframework.scheduling.aspectj;
 import java.lang.reflect.Method;
 import java.util.concurrent.Future;
 
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.scheduling.annotation.Async;
 
 /**
@@ -68,9 +68,9 @@ public aspect AnnotationAsyncExecutionAspect extends AbstractAsyncExecutionAspec
 	protected String getExecutorQualifier(Method method) {
 		// Maintainer's note: changes made here should also be made in
 		// AnnotationAsyncExecutionInterceptor#getExecutorQualifier
-		Async async = AnnotationUtils.findAnnotation(method, Async.class);
+		Async async = AnnotatedElementUtils.findMergedAnnotation(method, Async.class);
 		if (async == null) {
-			async = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Async.class);
+			async = AnnotatedElementUtils.findMergedAnnotation(method.getDeclaringClass(), Async.class);
 		}
 		return (async != null ? async.value() : null);
 	}

spring-context/src/main/java/org/springframework/context/annotation/BeanAnnotationHelper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * 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.
@@ -18,30 +18,27 @@
 
 import java.lang.reflect.Method;
 
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 
 /**
  * Utilities for processing {@link Bean}-annotated methods.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  * @since 3.1
  */
 class BeanAnnotationHelper {
 
-	/**
-	 * Return whether the given method is directly or indirectly annotated with
-	 * the {@link Bean} annotation.
-	 */
 	public static boolean isBeanAnnotated(Method method) {
-		return (AnnotationUtils.findAnnotation(method, Bean.class) != null);
+		return AnnotatedElementUtils.hasAnnotation(method, Bean.class);
 	}
 
 	public static String determineBeanNameFor(Method beanMethod) {
 		// By default, the bean name is the name of the @Bean-annotated method
 		String beanName = beanMethod.getName();
 
 		// Check to see if the user has explicitly set a custom bean name...
-		Bean bean = AnnotationUtils.findAnnotation(beanMethod, Bean.class);
+		Bean bean = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Bean.class);
 		if (bean != null && bean.name().length > 0) {
 			beanName = bean.name()[0];
 		}

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java

@@ -45,7 +45,7 @@
 import org.springframework.cglib.proxy.NoOp;
 import org.springframework.cglib.transform.ClassEmitterTransformer;
 import org.springframework.cglib.transform.TransformingClassGenerator;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.objenesis.ObjenesisException;
 import org.springframework.objenesis.SpringObjenesis;
 import org.springframework.util.Assert;
@@ -311,7 +311,7 @@ public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object
 			String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);
 
 			// Determine whether this bean is a scoped-proxy
-			Scope scope = AnnotationUtils.findAnnotation(beanMethod, Scope.class);
+			Scope scope = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Scope.class);
 			if (scope != null && scope.proxyMode() != ScopedProxyMode.NO) {
 				String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
 				if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * 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.
@@ -35,7 +35,6 @@
 import org.springframework.core.BridgeMethodResolver;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.annotation.AnnotatedElementUtils;
-import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.annotation.Order;
 import org.springframework.expression.EvaluationContext;
 import org.springframework.util.Assert;
@@ -214,7 +213,7 @@ private boolean shouldHandle(ApplicationEvent event, Object[] args) {
 	}
 
 	protected <A extends Annotation> A getMethodAnnotation(Class<A> annotationType) {
-		return AnnotationUtils.findAnnotation(this.method, annotationType);
+		return AnnotatedElementUtils.findMergedAnnotation(this.method, annotationType);
 	}
 
 	/**

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * 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.
@@ -39,8 +39,8 @@
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.MethodIntrospector;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
-import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.Assert;
 
 /**
@@ -129,7 +129,7 @@ protected void processBean(final List<EventListenerFactory> factories, final Str
 					new MethodIntrospector.MetadataLookup<EventListener>() {
 						@Override
 						public EventListener inspect(Method method) {
-							return AnnotationUtils.findAnnotation(method, EventListener.class);
+							return AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class);
 						}
 					});
 			if (annotatedMethods.isEmpty()) {

spring-context/src/main/java/org/springframework/scheduling/annotation/AnnotationAsyncExecutionInterceptor.java

@@ -21,7 +21,7 @@
 
 import org.springframework.aop.interceptor.AsyncExecutionInterceptor;
 import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 
 /**
  * Specialization of {@link AsyncExecutionInterceptor} that delegates method execution to
@@ -78,9 +78,9 @@ public AnnotationAsyncExecutionInterceptor(Executor defaultExecutor, AsyncUncaug
 	protected String getExecutorQualifier(Method method) {
 		// Maintainer's note: changes made here should also be made in
 		// AnnotationAsyncExecutionAspect#getExecutorQualifier
-		Async async = AnnotationUtils.findAnnotation(method, Async.class);
+		Async async = AnnotatedElementUtils.findMergedAnnotation(method, Async.class);
 		if (async == null) {
-			async = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Async.class);
+			async = AnnotatedElementUtils.findMergedAnnotation(method.getDeclaringClass(), Async.class);
 		}
 		return (async != null ? async.value() : null);
 	}

spring-context/src/test/java/org/springframework/context/event/AnnotationDrivenEventListenerTests.java

@@ -54,6 +54,7 @@
 import org.springframework.context.event.test.Identifiable;
 import org.springframework.context.event.test.TestEvent;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.core.annotation.AliasFor;
 import org.springframework.core.annotation.Order;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.scheduling.annotation.EnableAsync;
@@ -868,6 +869,16 @@ public void handleString(GenericEventPojo<String> value) {
 	}
 
 
+
+	@EventListener
+	@Retention(RetentionPolicy.RUNTIME)
+	public @interface ConditionalEvent {
+
+		@AliasFor(annotation = EventListener.class, attribute = "condition")
+		String value();
+	}
+
+
 	@Component
 	static class ConditionalEventListener extends TestEventListener {
 
@@ -883,12 +894,12 @@ public void handleString(String payload) {
 			super.handleString(payload);
 		}
 
-		@EventListener(condition = "#root.event.timestamp > #p0")
+		@ConditionalEvent("#root.event.timestamp > #p0")
 		public void handleTimestamp(Long timestamp) {
 			collectEvent(timestamp);
 		}
 
-		@EventListener(condition = "@conditionEvaluator.valid(#p0)")
+		@ConditionalEvent("@conditionEvaluator.valid(#p0)")
 		public void handleRatio(Double ratio) {
 			collectEvent(ratio);
 		}

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

@@ -271,10 +271,15 @@ public static boolean isAnnotated(AnnotatedElement element, final Class<? extend
 		Assert.notNull(element, "AnnotatedElement must not be null");
 		Assert.notNull(annotationType, "annotationType must not be null");
 
+		// Shortcut: directly present on the element, with no processing needed?
+		if (element.isAnnotationPresent(annotationType)) {
+			return true;
+		}
+
 		return Boolean.TRUE.equals(searchWithGetSemantics(element, annotationType, null, new SimpleAnnotationProcessor<Boolean>() {
 			@Override
 			public Boolean process(AnnotatedElement annotatedElement, Annotation annotation, int metaDepth) {
-				boolean found = annotation.annotationType() == annotationType;
+				boolean found = (annotation.annotationType() == annotationType);
 				return (found ? Boolean.TRUE : CONTINUE);
 			}
 		}));
@@ -324,6 +329,15 @@ public Boolean process(AnnotatedElement annotatedElement, Annotation annotation,
 	 * @see AnnotationUtils#synthesizeAnnotation(Map, Class, AnnotatedElement)
 	 */
 	public static <A extends Annotation> A getMergedAnnotation(AnnotatedElement element, Class<A> annotationType) {
+		Assert.notNull(annotationType, "annotationType must not be null");
+
+		// Shortcut: directly present on the element, with no merging needed?
+		A annotation = element.getAnnotation(annotationType);
+		if (annotation != null) {
+			return AnnotationUtils.synthesizeAnnotation(annotation, element);
+		}
+
+		// Exhaustive retrieval of merged annotation attributes...
 		AnnotationAttributes attributes = getMergedAnnotationAttributes(element, annotationType);
 		return AnnotationUtils.synthesizeAnnotation(attributes, annotationType, element);
 	}
@@ -412,6 +426,38 @@ public static AnnotationAttributes getMergedAnnotationAttributes(AnnotatedElemen
 		return attributes;
 	}
 
+	/**
+	 * Determine if an annotation of the specified {@code annotationType}
+	 * is <em>available</em> on the supplied {@link AnnotatedElement} or
+	 * within the annotation hierarchy <em>above</em> the specified element.
+	 * <p>If this method returns {@code true}, then {@link #findMergedAnnotationAttributes}
+	 * will return a non-null value.
+	 * <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 {@code true} if a matching annotation is present
+	 * @since 4.3
+	 */
+	public static boolean hasAnnotation(AnnotatedElement element, final Class<? extends Annotation> annotationType) {
+		Assert.notNull(element, "AnnotatedElement must not be null");
+		Assert.notNull(annotationType, "annotationType must not be null");
+
+		// Shortcut: directly present on the element, with no processing needed?
+		if (element.isAnnotationPresent(annotationType)) {
+			return true;
+		}
+
+		return Boolean.TRUE.equals(searchWithFindSemantics(element, annotationType, annotationType.getName(),
+				new SimpleAnnotationProcessor<Boolean>() {
+					@Override
+					public Boolean process(AnnotatedElement annotatedElement, Annotation annotation, int metaDepth) {
+						boolean found = (annotation.annotationType() == annotationType);
+						return (found ? Boolean.TRUE : CONTINUE);
+					}
+				}));
+	}
+
 	/**
 	 * Find the first annotation of the specified {@code annotationType} within
 	 * the annotation hierarchy <em>above</em> the supplied {@code element},
@@ -430,6 +476,14 @@ public static AnnotationAttributes getMergedAnnotationAttributes(AnnotatedElemen
 	 */
 	public static <A extends Annotation> A findMergedAnnotation(AnnotatedElement element, Class<A> annotationType) {
 		Assert.notNull(annotationType, "annotationType must not be null");
+
+		// Shortcut: directly present on the element, with no merging needed?
+		A annotation = element.getDeclaredAnnotation(annotationType);
+		if (annotation != null) {
+			return AnnotationUtils.synthesizeAnnotation(annotation, element);
+		}
+
+		// Exhaustive retrieval of merged annotation attributes...
 		AnnotationAttributes attributes = findMergedAnnotationAttributes(element, annotationType, false, false);
 		return AnnotationUtils.synthesizeAnnotation(attributes, annotationType, element);
 	}
@@ -483,9 +537,8 @@ public static <A extends Annotation> Set<A> findAllMergedAnnotations(AnnotatedEl
 		Assert.notNull(element, "AnnotatedElement must not be null");
 		Assert.notNull(annotationType, "annotationType must not be null");
 
-		MergedAnnotationAttributesProcessor processor = new MergedAnnotationAttributesProcessor(annotationType, null,
-			false, false, true);
-
+		MergedAnnotationAttributesProcessor processor =
+				new MergedAnnotationAttributesProcessor(annotationType, null, false, false, true);
 		searchWithFindSemantics(element, annotationType, annotationType.getName(), processor);
 
 		Set<A> annotations = new LinkedHashSet<A>();
@@ -831,8 +884,7 @@ private static <T> T searchWithFindSemantics(AnnotatedElement element, Class<? e
 			try {
 				// Locally declared annotations (ignoring @Inherited)
 				Annotation[] annotations = element.getDeclaredAnnotations();
-
-				List<T> aggregatedResults = processor.aggregates() ? new ArrayList<T>() : null;
+				List<T> aggregatedResults = (processor.aggregates() ? new ArrayList<T>() : null);
 
 				// Search in local annotations
 				for (Annotation annotation : annotations) {

spring-jms/src/main/java/org/springframework/jms/config/MethodJmsListenerEndpoint.java

@@ -25,7 +25,7 @@
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.config.EmbeddedValueResolver;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.jms.listener.MessageListenerContainer;
 import org.springframework.jms.listener.adapter.MessagingMessageListenerAdapter;
 import org.springframework.jms.support.converter.MessageConverter;
@@ -187,13 +187,11 @@ protected String getDefaultResponseDestination() {
 	}
 
 	private SendTo getSendTo(Method specificMethod) {
-		SendTo ann = AnnotationUtils.getAnnotation(specificMethod, SendTo.class);
-		if (ann != null) {
-			return ann;
-		}
-		else {
-			return AnnotationUtils.getAnnotation(specificMethod.getDeclaringClass(), SendTo.class);
+		SendTo ann = AnnotatedElementUtils.findMergedAnnotation(specificMethod, SendTo.class);
+		if (ann == null) {
+			ann = AnnotatedElementUtils.findMergedAnnotation(specificMethod.getDeclaringClass(), SendTo.class);
 		}
+		return ann;
 	}
 
 	private String resolve(String value) {