Bypass method traversal for annotation introspection if possible

The isCandidateClass mechanism is consistently used for a bypass check before method traversal attempts. While by default this is only bypassing standard java types, the same mechanism can be used with index metadata which indicates non-presence of certain annotations.

See gh-22420

spring-context/src/main/java/org/springframework/cache/annotation/AnnotationCacheOperationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -103,6 +103,16 @@ public class AnnotationCacheOperationSource extends AbstractFallbackCacheOperati
 	}
 
 
+	@Override
+	public boolean isCandidateClass(Class<?> targetClass) {
+		for (CacheAnnotationParser parser : this.annotationParsers) {
+			if (parser.isCandidateClass(targetClass)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	@Override
 	@Nullable
 	protected Collection<CacheOperation> findCacheOperations(Class<?> clazz) {
@@ -127,8 +137,8 @@ public class AnnotationCacheOperationSource extends AbstractFallbackCacheOperati
 	@Nullable
 	protected Collection<CacheOperation> determineCacheOperations(CacheOperationProvider provider) {
 		Collection<CacheOperation> ops = null;
-		for (CacheAnnotationParser annotationParser : this.annotationParsers) {
-			Collection<CacheOperation> annOps = provider.getCacheOperations(annotationParser);
+		for (CacheAnnotationParser parser : this.annotationParsers) {
+			Collection<CacheOperation> annOps = provider.getCacheOperations(parser);
 			if (annOps != null) {
 				if (ops == null) {
 					ops = annOps;

spring-context/src/main/java/org/springframework/cache/annotation/CacheAnnotationParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -30,12 +30,31 @@ import org.springframework.lang.Nullable;
  *
  * @author Costin Leau
  * @author Stephane Nicoll
+ * @author Juergen Hoeller
  * @since 3.1
  * @see AnnotationCacheOperationSource
  * @see SpringCacheAnnotationParser
  */
 public interface CacheAnnotationParser {
 
+	/**
+	 * Determine whether the given class is a candidate for cache operations
+	 * in the annotation format of this {@code CacheAnnotationParser}.
+	 * <p>If this method returns {@code false}, the methods on the given class
+	 * will not get traversed for {@code #parseCacheAnnotations} introspection.
+	 * Returning {@code false} is therefore an optimization for non-affected
+	 * classes, whereas {@code true} simply means that the class needs to get
+	 * fully introspected for each method on the given class individually.
+	 * @param targetClass the class to introspect
+	 * @return {@code false} if the class is known to have no cache operation
+	 * annotations at class or method level; {@code true} otherwise. The default
+	 * implementation returns {@code true}, leading to regular introspection.
+	 * @since 5.2
+	 */
+	default boolean isCandidateClass(Class<?> targetClass) {
+		return true;
+	}
+
 	/**
 	 * Parse the cache definition for the given class,
 	 * based on an annotation type understood by this parser.

spring-context/src/main/java/org/springframework/cache/annotation/SpringCacheAnnotationParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -30,6 +30,7 @@ import org.springframework.cache.interceptor.CacheOperation;
 import org.springframework.cache.interceptor.CachePutOperation;
 import org.springframework.cache.interceptor.CacheableOperation;
 import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
@@ -58,6 +59,11 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
 	}
 
 
+	@Override
+	public boolean isCandidateClass(Class<?> targetClass) {
+		return AnnotationUtils.isCandidateClass(targetClass, CACHE_OPERATION_ANNOTATIONS);
+	}
+
 	@Override
 	@Nullable
 	public Collection<CacheOperation> parseCacheAnnotations(Class<?> type) {

spring-context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -27,10 +27,29 @@ import org.springframework.lang.Nullable;
  * source level, or elsewhere.
  *
  * @author Costin Leau
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public interface CacheOperationSource {
 
+	/**
+	 * Determine whether the given class is a candidate for cache operations
+	 * in the metadata format of this {@code CacheOperationSource}.
+	 * <p>If this method returns {@code false}, the methods on the given class
+	 * will not get traversed for {@link #getCacheOperations} introspection.
+	 * Returning {@code false} is therefore an optimization for non-affected
+	 * classes, whereas {@code true} simply means that the class needs to get
+	 * fully introspected for each method on the given class individually.
+	 * @param targetClass the class to introspect
+	 * @return {@code false} if the class is known to have no cache operation
+	 * metadata at class or method level; {@code true} otherwise. The default
+	 * implementation returns {@code true}, leading to regular introspection.
+	 * @since 5.2
+	 */
+	default boolean isCandidateClass(Class<?> targetClass) {
+		return true;
+	}
+
 	/**
 	 * Return the collection of cache operations for this method, or {@code null}
 	 * if the method contains no <em>cacheable</em> annotations.

spring-context/src/main/java/org/springframework/cache/interceptor/CacheOperationSourcePointcut.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -19,6 +19,7 @@ package org.springframework.cache.interceptor;
 import java.io.Serializable;
 import java.lang.reflect.Method;
 
+import org.springframework.aop.ClassFilter;
 import org.springframework.aop.support.StaticMethodMatcherPointcut;
 import org.springframework.cache.CacheManager;
 import org.springframework.lang.Nullable;
@@ -36,11 +37,13 @@ import org.springframework.util.ObjectUtils;
 @SuppressWarnings("serial")
 abstract class CacheOperationSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {
 
+	protected CacheOperationSourcePointcut() {
+		setClassFilter(new CacheOperationSourceClassFilter());
+	}
+
+
 	@Override
 	public boolean matches(Method method, Class<?> targetClass) {
-		if (CacheManager.class.isAssignableFrom(targetClass)) {
-			return false;
-		}
 		CacheOperationSource cas = getCacheOperationSource();
 		return (cas != null && !CollectionUtils.isEmpty(cas.getCacheOperations(method, targetClass)));
 	}
@@ -75,4 +78,21 @@ abstract class CacheOperationSourcePointcut extends StaticMethodMatcherPointcut
 	@Nullable
 	protected abstract CacheOperationSource getCacheOperationSource();
 
+
+	/**
+	 * {@link ClassFilter} that delegates to {@link CacheOperationSource#isCandidateClass}
+	 * for filtering classes whose methods are not worth searching to begin with.
+	 */
+	private class CacheOperationSourceClassFilter implements ClassFilter {
+
+		@Override
+		public boolean matches(Class<?> clazz) {
+			if (CacheManager.class.isAssignableFrom(clazz)) {
+				return false;
+			}
+			CacheOperationSource cas = getCacheOperationSource();
+			return (cas == null || cas.isCandidateClass(clazz));
+		}
+	}
+
 }

spring-context/src/main/java/org/springframework/cache/interceptor/CompositeCacheOperationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -29,6 +29,7 @@ import org.springframework.util.Assert;
  * over a given array of {@code CacheOperationSource} instances.
  *
  * @author Costin Leau
+ * @author Juergen Hoeller
  * @since 3.1
  */
 @SuppressWarnings("serial")
@@ -42,7 +43,7 @@ public class CompositeCacheOperationSource implements CacheOperationSource, Seri
 	 * @param cacheOperationSources the CacheOperationSource instances to combine
 	 */
 	public CompositeCacheOperationSource(CacheOperationSource... cacheOperationSources) {
-		Assert.notEmpty(cacheOperationSources, "cacheOperationSources array must not be empty");
+		Assert.notEmpty(cacheOperationSources, "CacheOperationSource array must not be empty");
 		this.cacheOperationSources = cacheOperationSources;
 	}
 
@@ -54,18 +55,27 @@ public class CompositeCacheOperationSource implements CacheOperationSource, Seri
 		return this.cacheOperationSources;
 	}
 
+
+	@Override
+	public boolean isCandidateClass(Class<?> targetClass) {
+		for (CacheOperationSource source : this.cacheOperationSources) {
+			if (source.isCandidateClass(targetClass)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	@Override
 	@Nullable
 	public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) {
 		Collection<CacheOperation> ops = null;
-
 		for (CacheOperationSource source : this.cacheOperationSources) {
 			Collection<CacheOperation> cacheOperations = source.getCacheOperations(method, targetClass);
 			if (cacheOperations != null) {
 				if (ops == null) {
 					ops = new ArrayList<>();
 				}
-
 				ops.addAll(cacheOperations);
 			}
 		}

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

@@ -64,6 +64,7 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.BridgeMethodResolver;
 import org.springframework.core.MethodParameter;
 import org.springframework.core.Ordered;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.jndi.support.SimpleJndiBeanFactory;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -149,6 +150,8 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 	@Nullable
 	private static Class<? extends Annotation> ejbRefClass;
 
+	private static Set<Class<? extends Annotation>> resourceAnnotationTypes = new LinkedHashSet<>(4);
+
 	static {
 		try {
 			@SuppressWarnings("unchecked")
@@ -159,6 +162,7 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 		catch (ClassNotFoundException ex) {
 			webServiceRefClass = null;
 		}
+
 		try {
 			@SuppressWarnings("unchecked")
 			Class<? extends Annotation> clazz = (Class<? extends Annotation>)
@@ -168,6 +172,14 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 		catch (ClassNotFoundException ex) {
 			ejbRefClass = null;
 		}
+
+		resourceAnnotationTypes.add(Resource.class);
+		if (webServiceRefClass != null) {
+			resourceAnnotationTypes.add(webServiceRefClass);
+		}
+		if (ejbRefClass != null) {
+			resourceAnnotationTypes.add(ejbRefClass);
+		}
 	}
 
 
@@ -356,6 +368,10 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 	}
 
 	private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
+		if (!AnnotationUtils.isCandidateClass(clazz, resourceAnnotationTypes)) {
+			return new InjectionMetadata(clazz, Collections.emptyList());
+		}
+
 		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
 		Class<?> targetClass = clazz;
 

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

@@ -24,9 +24,13 @@ import java.util.Set;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
+import org.springframework.aop.framework.AopInfrastructureBean;
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
+import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.context.event.EventListenerFactory;
 import org.springframework.core.Conventions;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.AnnotationUtils;
@@ -96,6 +100,12 @@ abstract class ConfigurationClassUtils {
 			// Check already loaded Class if present...
 			// since we possibly can't even load the class file for this Class.
 			Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
+			if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
+					BeanPostProcessor.class.isAssignableFrom(beanClass) ||
+					AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
+					EventListenerFactory.class.isAssignableFrom(beanClass)) {
+				return false;
+			}
 			metadata = new StandardAnnotationMetadata(beanClass, true);
 		}
 		else {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -42,6 +42,7 @@ 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.lang.Nullable;
 import org.springframework.stereotype.Component;
 import org.springframework.util.Assert;
@@ -142,7 +143,10 @@ public class EventListenerMethodProcessor
 	}
 
 	private void processBean(final String beanName, final Class<?> targetType) {
-		if (!this.nonAnnotatedClasses.contains(targetType) && !isSpringContainerClass(targetType)) {
+		if (!this.nonAnnotatedClasses.contains(targetType) &&
+				AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
+				!isSpringContainerClass(targetType)) {
+
 			Map<Method, EventListener> annotatedMethods = null;
 			try {
 				annotatedMethods = MethodIntrospector.selectMethods(targetType,
@@ -155,6 +159,7 @@ public class EventListenerMethodProcessor
 					logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
 				}
 			}
+
 			if (CollectionUtils.isEmpty(annotatedMethods)) {
 				this.nonAnnotatedClasses.add(targetType);
 				if (logger.isTraceEnabled()) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -19,6 +19,7 @@ package org.springframework.scheduling.annotation;
 import java.lang.reflect.Method;
 import java.time.Duration;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.IdentityHashMap;
@@ -59,6 +60,7 @@ import org.springframework.core.MethodIntrospector;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.lang.Nullable;
 import org.springframework.scheduling.TaskScheduler;
 import org.springframework.scheduling.Trigger;
@@ -340,7 +342,8 @@ public class ScheduledAnnotationBeanPostProcessor
 		}
 
 		Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
-		if (!this.nonAnnotatedClasses.contains(targetClass)) {
+		if (!this.nonAnnotatedClasses.contains(targetClass) &&
+				AnnotationUtils.isCandidateClass(targetClass, Arrays.asList(Scheduled.class, Schedules.class))) {
 			Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
 					(MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
 						Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(