Avoid synthesizable annotation creation for @Bean/@scope processing

Includes consistent (non-)use of AnnotationUtils/AnnotatedElementUtils.

Issue: SPR-16933

Author: jhoeller

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

@@ -17,8 +17,11 @@
 package org.springframework.context.annotation;
 
 import java.lang.reflect.Method;
+import java.util.Map;
 
 import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.util.ConcurrentReferenceHashMap;
 
 /**
  * Utilities for processing {@link Bean}-annotated methods.
@@ -27,27 +30,45 @@
  * @author Juergen Hoeller
  * @since 3.1
  */
-final class BeanAnnotationHelper {
+abstract class BeanAnnotationHelper {
 
-	private BeanAnnotationHelper() {
-	}
+	private static final Map<Method, String> beanNameCache = new ConcurrentReferenceHashMap<>();
+
+	private static final Map<Method, Boolean> scopedProxyCache = new ConcurrentReferenceHashMap<>();
 
 
 	public static boolean isBeanAnnotated(Method method) {
 		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 = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Bean.class);
-		if (bean != null && bean.name().length > 0) {
-			beanName = bean.name()[0];
+		String beanName = beanNameCache.get(beanMethod);
+		if (beanName == null) {
+			// By default, the bean name is the name of the @Bean-annotated method
+			beanName = beanMethod.getName();
+			// Check to see if the user has explicitly set a custom bean name...
+			AnnotationAttributes bean =
+					AnnotatedElementUtils.findMergedAnnotationAttributes(beanMethod, Bean.class, false, false);
+			if (bean != null) {
+				String[] names = bean.getStringArray("name");
+				if (names.length > 0) {
+					beanName = names[0];
+				}
+			}
+			beanNameCache.put(beanMethod, beanName);
 		}
-
 		return beanName;
 	}
 
+	public static boolean isScopedProxy(Method beanMethod) {
+		Boolean scopedProxy = scopedProxyCache.get(beanMethod);
+		if (scopedProxy == null) {
+			AnnotationAttributes scope =
+					AnnotatedElementUtils.findMergedAnnotationAttributes(beanMethod, Scope.class, false, false);
+			scopedProxy = (scope != null && scope.getEnum("proxyMode") != ScopedProxyMode.NO);
+			scopedProxyCache.put(beanMethod, scopedProxy);
+		}
+		return scopedProxy;
+	}
+
 }

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

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

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

@@ -585,22 +585,20 @@ public static boolean hasAnnotation(AnnotatedElement element, Class<? extends An
 	 * attributes of the same name from higher levels, and
 	 * {@link AliasFor @AliasFor} semantics are fully supported, both
 	 * within a single annotation and within the annotation hierarchy.
-	 * <p>In contrast to {@link #getAllAnnotationAttributes}, the search
-	 * algorithm used by this method will stop searching the annotation
-	 * hierarchy once the first annotation of the specified
-	 * {@code annotationType} has been found. As a consequence, additional
-	 * annotations of the specified {@code annotationType} will be ignored.
+	 * <p>In contrast to {@link #getAllAnnotationAttributes}, the search algorithm
+	 * used by this method will stop searching the annotation hierarchy once the
+	 * first annotation of the specified {@code annotationType} has been found.
+	 * As a consequence, additional annotations of the specified
+	 * {@code annotationType} will be ignored.
 	 * <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
 	 * @param classValuesAsString whether to convert Class references into
 	 * Strings or to preserve them as Class references
-	 * @param nestedAnnotationsAsMap whether to convert nested Annotation
-	 * instances into {@code AnnotationAttributes} maps or to preserve them
-	 * as Annotation instances
-	 * @return the merged {@code AnnotationAttributes}, or {@code null} if
-	 * not found
+	 * @param nestedAnnotationsAsMap whether to convert nested Annotation instances into
+	 * {@code AnnotationAttributes} maps or to preserve them as Annotation instances
+	 * @return the merged {@code AnnotationAttributes}, or {@code null} if not found
 	 * @since 4.2
 	 * @see #findMergedAnnotation(AnnotatedElement, Class)
 	 * @see #getMergedAnnotationAttributes(AnnotatedElement, String, boolean, boolean)

spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationAttributesReadingVisitor.java

@@ -75,19 +75,26 @@ public void visitEnd() {
 			}
 			if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationClass.getName())) {
 				Set<Annotation> visited = new LinkedHashSet<>();
-				Annotation[] metaAnnotations = AnnotationUtils.getAnnotations(annotationClass);
-				if (!ObjectUtils.isEmpty(metaAnnotations)) {
-					for (Annotation metaAnnotation : metaAnnotations) {
-						if (!AnnotationUtils.isInJavaLangAnnotationPackage(metaAnnotation)) {
-							recursivelyCollectMetaAnnotations(visited, metaAnnotation);
+				try {
+					Annotation[] metaAnnotations = annotationClass.getAnnotations();
+					if (!ObjectUtils.isEmpty(metaAnnotations)) {
+						for (Annotation metaAnnotation : metaAnnotations) {
+							if (!AnnotationUtils.isInJavaLangAnnotationPackage(metaAnnotation)) {
+								recursivelyCollectMetaAnnotations(visited, metaAnnotation);
+							}
 						}
 					}
+					Set<String> metaAnnotationTypeNames = new LinkedHashSet<>(visited.size());
+					for (Annotation ann : visited) {
+						metaAnnotationTypeNames.add(ann.annotationType().getName());
+					}
+					this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
 				}
-				Set<String> metaAnnotationTypeNames = new LinkedHashSet<>(visited.size());
-				for (Annotation ann : visited) {
-					metaAnnotationTypeNames.add(ann.annotationType().getName());
+				catch (Throwable ex) {
+					if (logger.isDebugEnabled()) {
+						logger.debug("Failed to introspect meta-annotations on " + annotationClass + ": " + ex);
+					}
 				}
-				this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
 			}
 		}
 	}
@@ -110,7 +117,7 @@ private void recursivelyCollectMetaAnnotations(Set<Annotation> visited, Annotati
 			}
 			catch (Throwable ex) {
 				if (logger.isDebugEnabled()) {
-					logger.debug("Failed to introspect meta-annotations on [" + annotation + "]: " + ex);
+					logger.debug("Failed to introspect meta-annotations on " + annotation + ": " + ex);
 				}
 			}
 		}

spring-messaging/src/main/java/org/springframework/messaging/simp/annotation/support/SendToMethodReturnValueHandler.java

@@ -192,7 +192,6 @@ public void handleReturnValue(@Nullable Object returnValue, MethodParameter retu
 	}
 
 	private DestinationHelper getDestinationHelper(MessageHeaders headers, MethodParameter returnType) {
-
 		SendToUser m1 = AnnotatedElementUtils.findMergedAnnotation(returnType.getExecutable(), SendToUser.class);
 		SendTo m2 = AnnotatedElementUtils.findMergedAnnotation(returnType.getExecutable(), SendTo.class);
 		if ((m1 != null && !ObjectUtils.isEmpty(m1.value())) || (m2 != null && !ObjectUtils.isEmpty(m2.value()))) {
@@ -205,8 +204,8 @@ private DestinationHelper getDestinationHelper(MessageHeaders headers, MethodPar
 			return new DestinationHelper(headers, c1, c2);
 		}
 
-		return m1 != null || m2 != null ?
-			new DestinationHelper(headers, m1, m2) : new DestinationHelper(headers, c1, c2);
+		return (m1 != null || m2 != null ?
+				new DestinationHelper(headers, m1, m2) : new DestinationHelper(headers, c1, c2));
 	}
 
 	@Nullable
@@ -291,9 +290,9 @@ public SendToUser getSendToUser() {
 			return this.sendToUser;
 		}
 
-
 		public String expandTemplateVars(String destination) {
 			return placeholderHelper.replacePlaceholders(destination, this.placeholderResolver);
 		}
 	}
+
 }

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/ResponseBodyResultHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -22,7 +22,7 @@
 
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ReactiveAdapterRegistry;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.http.codec.HttpMessageWriter;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.reactive.HandlerResult;
@@ -53,9 +53,7 @@ public class ResponseBodyResultHandler extends AbstractMessageWriterResultHandle
 	 * @param writers writers for serializing to the response body
 	 * @param resolver to determine the requested content type
 	 */
-	public ResponseBodyResultHandler(List<HttpMessageWriter<?>> writers,
-			RequestedContentTypeResolver resolver) {
-
+	public ResponseBodyResultHandler(List<HttpMessageWriter<?>> writers, RequestedContentTypeResolver resolver) {
 		this(writers, resolver, ReactiveAdapterRegistry.getSharedInstance());
 	}
 
@@ -75,10 +73,10 @@ public ResponseBodyResultHandler(List<HttpMessageWriter<?>> writers,
 
 	@Override
 	public boolean supports(HandlerResult result) {
-		MethodParameter parameter = result.getReturnTypeSource();
-		Class<?> containingClass = parameter.getContainingClass();
-		return (AnnotationUtils.findAnnotation(containingClass, ResponseBody.class) != null ||
-				parameter.getMethodAnnotation(ResponseBody.class) != null);
+		MethodParameter returnType = result.getReturnTypeSource();
+		Class<?> containingClass = returnType.getContainingClass();
+		return (AnnotatedElementUtils.hasAnnotation(containingClass, ResponseBody.class) ||
+				returnType.hasMethodAnnotation(ResponseBody.class));
 	}
 
 	@Override