Polishing

Author: jhoeller

spring-aop/src/main/java/org/springframework/aop/framework/AdvisedSupport.java

@@ -22,7 +22,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -94,7 +93,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * List of Advisors. If an Advice is added, it will be wrapped
 	 * in an Advisor before being added to this List.
 	 */
-	private List<Advisor> advisors = new LinkedList<>();
+	private List<Advisor> advisors = new ArrayList<>();
 
 	/**
 	 * Array updated on changes to the advisors list, which is easier
@@ -474,7 +473,7 @@ public int countAdvicesOfType(@Nullable Class<?> adviceClass) {
 	 * for the given method, based on this configuration.
 	 * @param method the proxied method
 	 * @param targetClass the target class
-	 * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
+	 * @return a List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 	 */
 	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
 		MethodCacheKey cacheKey = new MethodCacheKey(method);
@@ -528,7 +527,7 @@ protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSo
 
 	/**
 	 * Build a configuration-only copy of this AdvisedSupport,
-	 * replacing the TargetSource
+	 * replacing the TargetSource.
 	 */
 	AdvisedSupport getConfigurationOnlyCopy() {
 		AdvisedSupport copy = new AdvisedSupport();

spring-aop/src/main/java/org/springframework/aop/framework/DefaultAdvisorChainFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -27,11 +27,11 @@
 
 import org.springframework.aop.Advisor;
 import org.springframework.aop.IntroductionAdvisor;
+import org.springframework.aop.IntroductionAwareMethodMatcher;
 import org.springframework.aop.MethodMatcher;
 import org.springframework.aop.PointcutAdvisor;
 import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;
 import org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry;
-import org.springframework.aop.support.MethodMatchers;
 import org.springframework.lang.Nullable;
 
 /**
@@ -53,19 +53,30 @@ public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
 
 		// This is somewhat tricky... We have to process introductions first,
 		// but we need to preserve order in the ultimate list.
-		List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length);
-		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
-		boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
 		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
+		Advisor[] advisors = config.getAdvisors();
+		List<Object> interceptorList = new ArrayList<>(advisors.length);
+		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
+		Boolean hasIntroductions = null;
 
-		for (Advisor advisor : config.getAdvisors()) {
+		for (Advisor advisor : advisors) {
 			if (advisor instanceof PointcutAdvisor) {
 				// Add it conditionally.
 				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
 				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
-					MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
 					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
-					if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
+					boolean match;
+					if (mm instanceof IntroductionAwareMethodMatcher) {
+						if (hasIntroductions == null) {
+							hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
+						}
+						match = ((IntroductionAwareMethodMatcher) mm).matches(method, targetClass, hasIntroductions);
+					}
+					else {
+						match = mm.matches(method, targetClass);
+					}
+					if (match) {
+						MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
 						if (mm.isRuntime()) {
 							// Creating a new object instance in the getInterceptors() method
 							// isn't a problem as we normally cache created chains.
@@ -98,9 +109,8 @@ else if (advisor instanceof IntroductionAdvisor) {
 	/**
 	 * Determine whether the Advisors contain matching introductions.
 	 */
-	private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {
-		for (int i = 0; i < config.getAdvisors().length; i++) {
-			Advisor advisor = config.getAdvisors()[i];
+	private static boolean hasMatchingIntroductions(Advisor[] advisors, Class<?> actualClass) {
+		for (Advisor advisor : advisors) {
 			if (advisor instanceof IntroductionAdvisor) {
 				IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
 				if (ia.getClassFilter().matches(actualClass)) {

spring-aop/src/main/java/org/springframework/aop/framework/adapter/AdvisorAdapterRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -31,15 +31,15 @@
 public interface AdvisorAdapterRegistry {
 
 	/**
-	 * Return an Advisor wrapping the given advice.
+	 * Return an {@link Advisor} wrapping the given advice.
 	 * <p>Should by default at least support
 	 * {@link org.aopalliance.intercept.MethodInterceptor},
 	 * {@link org.springframework.aop.MethodBeforeAdvice},
 	 * {@link org.springframework.aop.AfterReturningAdvice},
 	 * {@link org.springframework.aop.ThrowsAdvice}.
 	 * @param advice object that should be an advice
-	 * @return an Advisor wrapping the given advice. Never returns {@code null}.
-	 * If the advice parameter is an Advisor, return it.
+	 * @return an Advisor wrapping the given advice (never {@code null};
+	 * if the advice parameter is an Advisor, it is to be returned as-is)
 	 * @throws UnknownAdviceTypeException if no registered advisor adapter
 	 * can wrap the supposed advice
 	 */
@@ -48,21 +48,20 @@ public interface AdvisorAdapterRegistry {
 	/**
 	 * Return an array of AOP Alliance MethodInterceptors to allow use of the
 	 * given Advisor in an interception-based framework.
-	 * <p>Don't worry about the pointcut associated with the Advisor,
-	 * if it's a PointcutAdvisor: just return an interceptor.
+	 * <p>Don't worry about the pointcut associated with the {@link Advisor}, if it is
+	 * a {@link org.springframework.aop.PointcutAdvisor}: just return an interceptor.
 	 * @param advisor Advisor to find an interceptor for
 	 * @return an array of MethodInterceptors to expose this Advisor's behavior
 	 * @throws UnknownAdviceTypeException if the Advisor type is
-	 * not understood by any registered AdvisorAdapter.
+	 * not understood by any registered AdvisorAdapter
 	 */
 	MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException;
 
 	/**
-	 * Register the given AdvisorAdapter. Note that it is not necessary to register
+	 * Register the given {@link AdvisorAdapter}. Note that it is not necessary to register
 	 * adapters for an AOP Alliance Interceptors or Spring Advices: these must be
-	 * automatically recognized by an AdvisorAdapterRegistry implementation.
-	 * @param adapter AdvisorAdapter that understands a particular Advisor
-	 * or Advice types
+	 * automatically recognized by an {@code AdvisorAdapterRegistry} implementation.
+	 * @param adapter AdvisorAdapter that understands particular Advisor or Advice types
 	 */
 	void registerAdvisorAdapter(AdvisorAdapter adapter);
 

spring-aop/src/main/java/org/springframework/aop/interceptor/SimpleAsyncUncaughtExceptionHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -29,13 +29,13 @@
  */
 public class SimpleAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {
 
-	private final Log logger = LogFactory.getLog(SimpleAsyncUncaughtExceptionHandler.class);
+	private static final Log logger = LogFactory.getLog(SimpleAsyncUncaughtExceptionHandler.class);
+
 
 	@Override
 	public void handleUncaughtException(Throwable ex, Method method, Object... params) {
 		if (logger.isErrorEnabled()) {
-			logger.error(String.format("Unexpected error occurred invoking async " +
-					"method '%s'.", method), ex);
+			logger.error("Unexpected error occurred invoking async method: " + method, ex);
 		}
 	}
 

spring-context-support/src/main/java/org/springframework/cache/jcache/config/AbstractJCacheConfiguration.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.
@@ -25,6 +25,7 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Role;
+import org.springframework.lang.Nullable;
 
 /**
  * Abstract JSR-107 specific {@code @Configuration} class providing common
@@ -37,8 +38,10 @@
 @Configuration
 public class AbstractJCacheConfiguration extends AbstractCachingConfiguration {
 
+	@Nullable
 	protected CacheResolver exceptionCacheResolver;
 
+
 	@Override
 	protected void useCachingConfigurer(CachingConfigurer config) {
 		super.useCachingConfigurer(config);

spring-context-support/src/main/java/org/springframework/cache/jcache/config/JCacheConfigurer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -18,6 +18,7 @@
 
 import org.springframework.cache.annotation.CachingConfigurer;
 import org.springframework.cache.interceptor.CacheResolver;
+import org.springframework.lang.Nullable;
 
 /**
  * Extension of {@link CachingConfigurer} for the JSR-107 implementation.
@@ -58,6 +59,7 @@ public interface JCacheConfigurer extends CachingConfigurer {
 	 * </pre>
 	 * See {@link org.springframework.cache.annotation.EnableCaching} for more complete examples.
 	 */
+	@Nullable
 	CacheResolver exceptionCacheResolver();
 
 }

spring-context-support/src/main/java/org/springframework/cache/jcache/config/JCacheConfigurerSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -18,6 +18,7 @@
 
 import org.springframework.cache.annotation.CachingConfigurerSupport;
 import org.springframework.cache.interceptor.CacheResolver;
+import org.springframework.lang.Nullable;
 
 /**
  * An extension of {@link CachingConfigurerSupport} that also implements
@@ -34,6 +35,7 @@
 public class JCacheConfigurerSupport extends CachingConfigurerSupport implements JCacheConfigurer {
 
 	@Override
+	@Nullable
 	public CacheResolver exceptionCacheResolver() {
 		return null;
 	}

spring-context-support/src/main/java/org/springframework/cache/jcache/config/package-info.java

@@ -6,4 +6,9 @@
  * <p>Provide an extension of the {@code CachingConfigurer} that exposes
  * the exception cache resolver to use, see {@code JCacheConfigurer}.
  */
+@NonNullApi
+@NonNullFields
 package org.springframework.cache.jcache.config;
+
+import org.springframework.lang.NonNullApi;
+import org.springframework.lang.NonNullFields;

spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractCacheInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -49,6 +49,7 @@ protected AbstractCacheInterceptor(CacheErrorHandler errorHandler) {
 	}
 
 
+	@Nullable
 	protected abstract Object invoke(CacheOperationInvocationContext<O> context, CacheOperationInvoker invoker)
 			throws Throwable;
 

spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractFallbackJCacheOperationSource.java

@@ -55,7 +55,7 @@ public abstract class AbstractFallbackJCacheOperationSource implements JCacheOpe
 
 
 	@Override
-	public JCacheOperation<?> getCacheOperation(Method method, Class<?> targetClass) {
+	public JCacheOperation<?> getCacheOperation(Method method, @Nullable Class<?> targetClass) {
 		MethodClassKey cacheKey = new MethodClassKey(method, targetClass);
 		Object cached = this.cache.get(cacheKey);
 
@@ -78,7 +78,7 @@ public JCacheOperation<?> getCacheOperation(Method method, Class<?> targetClass)
 	}
 
 	@Nullable
-	private JCacheOperation<?> computeCacheOperation(Method method, Class<?> targetClass) {
+	private JCacheOperation<?> computeCacheOperation(Method method, @Nullable Class<?> targetClass) {
 		// Don't allow no-public methods as required.
 		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
 			return null;
@@ -113,7 +113,7 @@ private JCacheOperation<?> computeCacheOperation(Method method, Class<?> targetC
 	 * (or {@code null} if none)
 	 */
 	@Nullable
-	protected abstract JCacheOperation<?> findCacheOperation(Method method, Class<?> targetType);
+	protected abstract JCacheOperation<?> findCacheOperation(Method method, @Nullable Class<?> targetType);
 
 	/**
 	 * Should only public methods be allowed to have caching semantics?

spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java

@@ -50,7 +50,7 @@ abstract class AbstractJCacheOperation<A extends Annotation> implements JCacheOp
 
 
 	/**
-	 * Create a new instance.
+	 * Construct a new {@code AbstractJCacheOperation}.
 	 * @param methodDetails the {@link CacheMethodDetails} related to the cached method
 	 * @param cacheResolver the cache resolver to resolve regular caches
 	 */

spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractKeyCacheInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -37,6 +37,7 @@ protected AbstractKeyCacheInterceptor(CacheErrorHandler errorHandler) {
 		super(errorHandler);
 	}
 
+
 	/**
 	 * Generate a key for the specified invocation.
 	 * @param context the context of the invocation
@@ -56,8 +57,7 @@ protected Object generateKey(CacheOperationInvocationContext<O> context) {
 	 * @param context the context of the invocation.
 	 * @return the related {@code CacheKeyInvocationContext}
 	 */
-	protected CacheKeyInvocationContext<A> createCacheKeyInvocationContext(
-			CacheOperationInvocationContext<O> context) {
+	protected CacheKeyInvocationContext<A> createCacheKeyInvocationContext(CacheOperationInvocationContext<O> context) {
 		return new DefaultCacheKeyInvocationContext<>(context.getOperation(), context.getTarget(), context.getArgs());
 	}