Polishing

spring-context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.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.
@@ -313,9 +313,9 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
 	 * @param expectedType type for the bean
 	 * @return the bean matching that name
 	 * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException if such bean does not exist
-	 * @see CacheOperation#keyGenerator
+	 * @see CacheOperation#getKeyGenerator()
-	 * @see CacheOperation#cacheManager
+	 * @see CacheOperation#getCacheManager()
-	 * @see CacheOperation#cacheResolver
+	 * @see CacheOperation#getCacheResolver()
 	 */
 	protected <T> T getBean(String beanName, Class<T> expectedType) {
 		if (this.beanFactory == null) {
@@ -353,8 +353,8 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
 
 	/**
 	 * Execute the underlying operation (typically in case of cache miss) and return
-	 * the result of the invocation. If an exception occurs it will be wrapped in
+	 * the result of the invocation. If an exception occurs it will be wrapped in a
-	 * a {@link CacheOperationInvoker.ThrowableWrapper}: the exception can be handled
+	 * {@link CacheOperationInvoker.ThrowableWrapper}: the exception can be handled
 	 * or modified but it <em>must</em> be wrapped in a
 	 * {@link CacheOperationInvoker.ThrowableWrapper} as well.
 	 * @param invoker the invoker handling the operation being cached

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,13 +27,14 @@ import org.springframework.lang.Nullable;
  * source level, or elsewhere.
  *
  * @author Costin Leau
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public interface CacheOperationSource {
 
 	/**
-	 * Return the collection of cache operations for this method, or {@code null}
+	 * Return the collection of cache operations for this method,
-	 * if the method contains no <em>cacheable</em> annotations.
+	 * or {@code null} if the method contains no <em>cacheable</em> annotations.
 	 * @param method the method to introspect
 	 * @param targetClass the target class (may be {@code null}, in which case
 	 * the declaring class of the method must be used)

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,21 +55,21 @@ public class CompositeCacheOperationSource implements CacheOperationSource, Seri
 		return this.cacheOperationSources;
 	}
 
+
 	@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);
 			}
 		}
 		return ops;
 	}
+
 }

spring-context/src/main/java/org/springframework/scripting/support/StandardScriptFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -36,7 +36,7 @@ import org.springframework.util.StringUtils;
 /**
  * {@link org.springframework.scripting.ScriptFactory} implementation based
  * on the JSR-223 script engine abstraction (as included in Java 6+).
- * Supports JavaScript, Groovy, JRuby and other JSR-223 compliant engines.
+ * Supports JavaScript, Groovy, JRuby, and other JSR-223 compliant engines.
  *
  * <p>Typically used in combination with a
  * {@link org.springframework.scripting.support.ScriptFactoryPostProcessor};
@@ -151,6 +151,7 @@ public class StandardScriptFactory implements ScriptFactory, BeanClassLoaderAwar
 				if (script instanceof Class ? !requestedIfc.isAssignableFrom((Class<?>) script) :
 						!requestedIfc.isInstance(script)) {
 					adaptationRequired = true;
+					break;
 				}
 			}
 			if (adaptationRequired) {

spring-core/src/main/java/org/springframework/lang/NonNull.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.
@@ -26,8 +26,9 @@ import javax.annotation.meta.TypeQualifierNickname;
 
 /**
  * A common Spring annotation to declare that annotated elements cannot be {@code null}.
- * Leverages JSR 305 meta-annotations to indicate nullability in Java to common tools with
+ *
- * JSR 305 support and used by Kotlin to infer nullability of Spring API.
+ * <p>Leverages JSR-305 meta-annotations to indicate nullability in Java to common
+ * tools with JSR-305 support and used by Kotlin to infer nullability of Spring API.
  *
  * <p>Should be used at parameter, return value, and field level. Method overrides should
  * repeat parent {@code @NonNull} annotations unless they behave differently.

spring-core/src/main/java/org/springframework/lang/NonNullFields.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -36,7 +36,7 @@ import javax.annotation.meta.TypeQualifierDefault;
  *
  * @author Sebastien Deleuze
  * @since 5.0
- * @see NonNullFields
+ * @see NonNullApi
  * @see Nullable
  * @see NonNull
  */

spring-core/src/main/java/org/springframework/lang/Nullable.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.
@@ -27,8 +27,10 @@ import javax.annotation.meta.When;
 
 /**
  * A common Spring annotation to declare that annotated elements can be {@code null} under
- * some circumstance. Leverages JSR 305 meta-annotations to indicate nullability in Java
+ * some circumstance.
- * to common tools with JSR 305 support and used by Kotlin to infer nullability of Spring API.
+ *
+ * <p>Leverages JSR-305 meta-annotations to indicate nullability in Java to common
+ * tools with JSR-305 support and used by Kotlin to infer nullability of Spring API.
  *
  * <p>Should be used at parameter, return value, and field level. Methods override should
  * repeat parent {@code @Nullable} annotations unless they behave differently.

spring-core/src/main/java/org/springframework/util/ReflectionUtils.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.
@@ -61,13 +61,13 @@ public abstract class ReflectionUtils {
 	 * @since 3.0.5
 	 */
 	public static final MethodFilter USER_DECLARED_METHODS =
-			(method -> (!method.isBridge() && !method.isSynthetic() && method.getDeclaringClass() != Object.class));
+			(method -> !method.isBridge() && !method.isSynthetic() && method.getDeclaringClass() != Object.class);
 
 	/**
 	 * Pre-built FieldFilter that matches all non-static, non-final fields.
 	 */
 	public static final FieldFilter COPYABLE_FIELDS =
-			field -> !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers()));
+			(field -> !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())));
 
 
 	/**
@@ -76,9 +76,9 @@ public abstract class ReflectionUtils {
 	 */
 	private static final String CGLIB_RENAMED_METHOD_PREFIX = "CGLIB$";
 
-	private static final Method[] NO_METHODS = {};
+	private static final Method[] EMPTY_METHOD_ARRAY = new Method[0];
 
-	private static final Field[] NO_FIELDS = {};
+	private static final Field[] EMPTY_FIELD_ARRAY = new Field[0];
 
 
 	/**
@@ -93,88 +93,124 @@ public abstract class ReflectionUtils {
 	private static final Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap<>(256);
 
 
+	// Exception handling
+
 	/**
-	 * Attempt to find a {@link Field field} on the supplied {@link Class} with the
+	 * Handle the given reflection exception. Should only be called if no
-	 * supplied {@code name}. Searches all superclasses up to {@link Object}.
+	 * checked exception is expected to be thrown by the target method.
-	 * @param clazz the class to introspect
+	 * <p>Throws the underlying RuntimeException or Error in case of an
-	 * @param name the name of the field
+	 * InvocationTargetException with such a root cause. Throws an
-	 * @return the corresponding Field object, or {@code null} if not found
+	 * IllegalStateException with an appropriate message or
+	 * UndeclaredThrowableException otherwise.
+	 * @param ex the reflection exception to handle
 	 */
-	@Nullable
+	public static void handleReflectionException(Exception ex) {
-	public static Field findField(Class<?> clazz, String name) {
+		if (ex instanceof NoSuchMethodException) {
-		return findField(clazz, name, null);
+			throw new IllegalStateException("Method not found: " + ex.getMessage());
+		}
+		if (ex instanceof IllegalAccessException) {
+			throw new IllegalStateException("Could not access method: " + ex.getMessage());
+		}
+		if (ex instanceof InvocationTargetException) {
+			handleInvocationTargetException((InvocationTargetException) ex);
+		}
+		if (ex instanceof RuntimeException) {
+			throw (RuntimeException) ex;
+		}
+		throw new UndeclaredThrowableException(ex);
 	}
 
 	/**
-	 * Attempt to find a {@link Field field} on the supplied {@link Class} with the
+	 * Handle the given invocation target exception. Should only be called if no
-	 * supplied {@code name} and/or {@link Class type}. Searches all superclasses
+	 * checked exception is expected to be thrown by the target method.
-	 * up to {@link Object}.
+	 * <p>Throws the underlying RuntimeException or Error in case of such a root
-	 * @param clazz the class to introspect
+	 * cause. Throws an UndeclaredThrowableException otherwise.
-	 * @param name the name of the field (may be {@code null} if type is specified)
+	 * @param ex the invocation target exception to handle
-	 * @param type the type of the field (may be {@code null} if name is specified)
-	 * @return the corresponding Field object, or {@code null} if not found
 	 */
-	@Nullable
+	public static void handleInvocationTargetException(InvocationTargetException ex) {
-	public static Field findField(Class<?> clazz, @Nullable String name, @Nullable Class<?> type) {
+		rethrowRuntimeException(ex.getTargetException());
-		Assert.notNull(clazz, "Class must not be null");
-		Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
-		Class<?> searchType = clazz;
-		while (Object.class != searchType && searchType != null) {
-			Field[] fields = getDeclaredFields(searchType);
-			for (Field field : fields) {
-				if ((name == null || name.equals(field.getName())) &&
-						(type == null || type.equals(field.getType()))) {
-					return field;
-				}
-			}
-			searchType = searchType.getSuperclass();
-		}
-		return null;
 	}
 
 	/**
-	 * Set the field represented by the supplied {@link Field field object} on the
+	 * Rethrow the given {@link Throwable exception}, which is presumably the
-	 * specified {@link Object target object} to the specified {@code value}.
+	 * <em>target exception</em> of an {@link InvocationTargetException}.
-	 * In accordance with {@link Field#set(Object, Object)} semantics, the new value
+	 * Should only be called if no checked exception is expected to be thrown
-	 * is automatically unwrapped if the underlying field has a primitive type.
+	 * by the target method.
-	 * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
+	 * <p>Rethrows the underlying exception cast to a {@link RuntimeException} or
-	 * @param field the field to set
+	 * {@link Error} if appropriate; otherwise, throws an
-	 * @param target the target object on which to set the field
+	 * {@link UndeclaredThrowableException}.
-	 * @param value the value to set (may be {@code null})
+	 * @param ex the exception to rethrow
+	 * @throws RuntimeException the rethrown exception
 	 */
-	public static void setField(Field field, @Nullable Object target, @Nullable Object value) {
+	public static void rethrowRuntimeException(Throwable ex) {
-		try {
+		if (ex instanceof RuntimeException) {
-			field.set(target, value);
+			throw (RuntimeException) ex;
 		}
-		catch (IllegalAccessException ex) {
+		if (ex instanceof Error) {
-			handleReflectionException(ex);
+			throw (Error) ex;
-			throw new IllegalStateException(
-					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
 		}
+		throw new UndeclaredThrowableException(ex);
 	}
 
 	/**
-	 * Get the field represented by the supplied {@link Field field object} on the
+	 * Rethrow the given {@link Throwable exception}, which is presumably the
-	 * specified {@link Object target object}. In accordance with {@link Field#get(Object)}
+	 * <em>target exception</em> of an {@link InvocationTargetException}.
-	 * semantics, the returned value is automatically wrapped if the underlying field
+	 * Should only be called if no checked exception is expected to be thrown
-	 * has a primitive type.
+	 * by the target method.
-	 * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
+	 * <p>Rethrows the underlying exception cast to an {@link Exception} or
-	 * @param field the field to get
+	 * {@link Error} if appropriate; otherwise, throws an
-	 * @param target the target object from which to get the field
+	 * {@link UndeclaredThrowableException}.
-	 * @return the field's current value
+	 * @param ex the exception to rethrow
+	 * @throws Exception the rethrown exception (in case of a checked exception)
 	 */
-	@Nullable
+	public static void rethrowException(Throwable ex) throws Exception {
-	public static Object getField(Field field, @Nullable Object target) {
+		if (ex instanceof Exception) {
-		try {
+			throw (Exception) ex;
-			return field.get(target);
 		}
-		catch (IllegalAccessException ex) {
+		if (ex instanceof Error) {
-			handleReflectionException(ex);
+			throw (Error) ex;
-			throw new IllegalStateException(
+		}
-					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
+		throw new UndeclaredThrowableException(ex);
+	}
+
+
+	// Constructor handling
+
+	/**
+	 * Obtain an accessible constructor for the given class and parameters.
+	 * @param clazz the clazz to check
+	 * @param parameterTypes the parameter types of the desired constructor
+	 * @return the constructor reference
+	 * @throws NoSuchMethodException if no such constructor exists
+	 * @since 5.0
+	 */
+	public static <T> Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes)
+			throws NoSuchMethodException {
+
+		Constructor<T> ctor = clazz.getDeclaredConstructor(parameterTypes);
+		makeAccessible(ctor);
+		return ctor;
+	}
+
+	/**
+	 * Make the given constructor accessible, explicitly setting it accessible
+	 * if necessary. The {@code setAccessible(true)} method is only called
+	 * when actually necessary, to avoid unnecessary conflicts with a JVM
+	 * SecurityManager (if active).
+	 * @param ctor the constructor to make accessible
+	 * @see java.lang.reflect.Constructor#setAccessible
+	 */
+	@SuppressWarnings("deprecation")  // on JDK 9
+	public static void makeAccessible(Constructor<?> ctor) {
+		if ((!Modifier.isPublic(ctor.getModifiers()) ||
+				!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) {
+			ctor.setAccessible(true);
 		}
 	}
 
+
+	// Method handling
+
 	/**
 	 * Attempt to find a {@link Method} on the supplied class with the supplied name
 	 * and no parameters. Searches all superclasses up to {@code Object}.
@@ -297,84 +333,6 @@ public abstract class ReflectionUtils {
 		throw new IllegalStateException("Should never get here");
 	}
 
-	/**
-	 * Handle the given reflection exception. Should only be called if no
-	 * checked exception is expected to be thrown by the target method.
-	 * <p>Throws the underlying RuntimeException or Error in case of an
-	 * InvocationTargetException with such a root cause. Throws an
-	 * IllegalStateException with an appropriate message or
-	 * UndeclaredThrowableException otherwise.
-	 * @param ex the reflection exception to handle
-	 */
-	public static void handleReflectionException(Exception ex) {
-		if (ex instanceof NoSuchMethodException) {
-			throw new IllegalStateException("Method not found: " + ex.getMessage());
-		}
-		if (ex instanceof IllegalAccessException) {
-			throw new IllegalStateException("Could not access method: " + ex.getMessage());
-		}
-		if (ex instanceof InvocationTargetException) {
-			handleInvocationTargetException((InvocationTargetException) ex);
-		}
-		if (ex instanceof RuntimeException) {
-			throw (RuntimeException) ex;
-		}
-		throw new UndeclaredThrowableException(ex);
-	}
-
-	/**
-	 * Handle the given invocation target exception. Should only be called if no
-	 * checked exception is expected to be thrown by the target method.
-	 * <p>Throws the underlying RuntimeException or Error in case of such a root
-	 * cause. Throws an UndeclaredThrowableException otherwise.
-	 * @param ex the invocation target exception to handle
-	 */
-	public static void handleInvocationTargetException(InvocationTargetException ex) {
-		rethrowRuntimeException(ex.getTargetException());
-	}
-
-	/**
-	 * Rethrow the given {@link Throwable exception}, which is presumably the
-	 * <em>target exception</em> of an {@link InvocationTargetException}.
-	 * Should only be called if no checked exception is expected to be thrown
-	 * by the target method.
-	 * <p>Rethrows the underlying exception cast to a {@link RuntimeException} or
-	 * {@link Error} if appropriate; otherwise, throws an
-	 * {@link UndeclaredThrowableException}.
-	 * @param ex the exception to rethrow
-	 * @throws RuntimeException the rethrown exception
-	 */
-	public static void rethrowRuntimeException(Throwable ex) {
-		if (ex instanceof RuntimeException) {
-			throw (RuntimeException) ex;
-		}
-		if (ex instanceof Error) {
-			throw (Error) ex;
-		}
-		throw new UndeclaredThrowableException(ex);
-	}
-
-	/**
-	 * Rethrow the given {@link Throwable exception}, which is presumably the
-	 * <em>target exception</em> of an {@link InvocationTargetException}.
-	 * Should only be called if no checked exception is expected to be thrown
-	 * by the target method.
-	 * <p>Rethrows the underlying exception cast to an {@link Exception} or
-	 * {@link Error} if appropriate; otherwise, throws an
-	 * {@link UndeclaredThrowableException}.
-	 * @param ex the exception to rethrow
-	 * @throws Exception the rethrown exception (in case of a checked exception)
-	 */
-	public static void rethrowException(Throwable ex) throws Exception {
-		if (ex instanceof Exception) {
-			throw (Exception) ex;
-		}
-		if (ex instanceof Error) {
-			throw (Error) ex;
-		}
-		throw new UndeclaredThrowableException(ex);
-	}
-
 	/**
 	 * Determine whether the given method explicitly declares the given
 	 * exception or one of its superclasses, which means that an exception
@@ -395,143 +353,6 @@ public abstract class ReflectionUtils {
 		return false;
 	}
 
-	/**
-	 * Determine whether the given field is a "public static final" constant.
-	 * @param field the field to check
-	 */
-	public static boolean isPublicStaticFinal(Field field) {
-		int modifiers = field.getModifiers();
-		return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
-	}
-
-	/**
-	 * Determine whether the given method is an "equals" method.
-	 * @see java.lang.Object#equals(Object)
-	 */
-	public static boolean isEqualsMethod(@Nullable Method method) {
-		if (method == null || !method.getName().equals("equals")) {
-			return false;
-		}
-		Class<?>[] paramTypes = method.getParameterTypes();
-		return (paramTypes.length == 1 && paramTypes[0] == Object.class);
-	}
-
-	/**
-	 * Determine whether the given method is a "hashCode" method.
-	 * @see java.lang.Object#hashCode()
-	 */
-	public static boolean isHashCodeMethod(@Nullable Method method) {
-		return (method != null && method.getName().equals("hashCode") && method.getParameterCount() == 0);
-	}
-
-	/**
-	 * Determine whether the given method is a "toString" method.
-	 * @see java.lang.Object#toString()
-	 */
-	public static boolean isToStringMethod(@Nullable Method method) {
-		return (method != null && method.getName().equals("toString") && method.getParameterCount() == 0);
-	}
-
-	/**
-	 * Determine whether the given method is originally declared by {@link java.lang.Object}.
-	 */
-	public static boolean isObjectMethod(@Nullable Method method) {
-		if (method == null) {
-			return false;
-		}
-		try {
-			Object.class.getDeclaredMethod(method.getName(), method.getParameterTypes());
-			return true;
-		}
-		catch (Exception ex) {
-			return false;
-		}
-	}
-
-	/**
-	 * Determine whether the given method is a CGLIB 'renamed' method,
-	 * following the pattern "CGLIB$methodName$0".
-	 * @param renamedMethod the method to check
-	 * @see org.springframework.cglib.proxy.Enhancer#rename
-	 */
-	public static boolean isCglibRenamedMethod(Method renamedMethod) {
-		String name = renamedMethod.getName();
-		if (name.startsWith(CGLIB_RENAMED_METHOD_PREFIX)) {
-			int i = name.length() - 1;
-			while (i >= 0 && Character.isDigit(name.charAt(i))) {
-				i--;
-			}
-			return ((i > CGLIB_RENAMED_METHOD_PREFIX.length()) &&
-						(i < name.length() - 1) && name.charAt(i) == '$');
-		}
-		return false;
-	}
-
-	/**
-	 * Make the given field accessible, explicitly setting it accessible if
-	 * necessary. The {@code setAccessible(true)} method is only called
-	 * when actually necessary, to avoid unnecessary conflicts with a JVM
-	 * SecurityManager (if active).
-	 * @param field the field to make accessible
-	 * @see java.lang.reflect.Field#setAccessible
-	 */
-	@SuppressWarnings("deprecation")  // on JDK 9
-	public static void makeAccessible(Field field) {
-		if ((!Modifier.isPublic(field.getModifiers()) ||
-				!Modifier.isPublic(field.getDeclaringClass().getModifiers()) ||
-				Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
-			field.setAccessible(true);
-		}
-	}
-
-	/**
-	 * Make the given method accessible, explicitly setting it accessible if
-	 * necessary. The {@code setAccessible(true)} method is only called
-	 * when actually necessary, to avoid unnecessary conflicts with a JVM
-	 * SecurityManager (if active).
-	 * @param method the method to make accessible
-	 * @see java.lang.reflect.Method#setAccessible
-	 */
-	@SuppressWarnings("deprecation")  // on JDK 9
-	public static void makeAccessible(Method method) {
-		if ((!Modifier.isPublic(method.getModifiers()) ||
-				!Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) {
-			method.setAccessible(true);
-		}
-	}
-
-	/**
-	 * Make the given constructor accessible, explicitly setting it accessible
-	 * if necessary. The {@code setAccessible(true)} method is only called
-	 * when actually necessary, to avoid unnecessary conflicts with a JVM
-	 * SecurityManager (if active).
-	 * @param ctor the constructor to make accessible
-	 * @see java.lang.reflect.Constructor#setAccessible
-	 */
-	@SuppressWarnings("deprecation")  // on JDK 9
-	public static void makeAccessible(Constructor<?> ctor) {
-		if ((!Modifier.isPublic(ctor.getModifiers()) ||
-				!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) {
-			ctor.setAccessible(true);
-		}
-	}
-
-	/**
-	 * Obtain an accessible constructor for the given class and parameters.
-	 * @param clazz the clazz to check
-	 * @param parameterTypes the parameter types of the desired constructor
-	 * @return the constructor reference
-	 * @throws NoSuchMethodException if no such constructor exists
-	 * @since 5.0
-	 */
-	public static <T> Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes)
-			throws NoSuchMethodException {
-
-		Constructor<T> ctor = clazz.getDeclaredConstructor(parameterTypes);
-		makeAccessible(ctor);
-		return ctor;
-	}
-
 	/**
 	 * Perform the given callback operation on all matching methods of the given
 	 * class, as locally declared or equivalent thereof (such as default methods
@@ -611,7 +432,7 @@ public abstract class ReflectionUtils {
 	public static Method[] getAllDeclaredMethods(Class<?> leafClass) {
 		final List<Method> methods = new ArrayList<>(32);
 		doWithMethods(leafClass, methods::add);
-		return methods.toArray(new Method[0]);
+		return methods.toArray(EMPTY_METHOD_ARRAY);
 	}
 
 	/**
@@ -647,7 +468,7 @@ public abstract class ReflectionUtils {
 				methods.add(method);
 			}
 		});
-		return methods.toArray(new Method[0]);
+		return methods.toArray(EMPTY_METHOD_ARRAY);
 	}
 
 	/**
@@ -679,7 +500,7 @@ public abstract class ReflectionUtils {
 				else {
 					result = declaredMethods;
 				}
-				declaredMethodsCache.put(clazz, (result.length == 0 ? NO_METHODS : result));
+				declaredMethodsCache.put(clazz, (result.length == 0 ? EMPTY_METHOD_ARRAY : result));
 			}
 			catch (Throwable ex) {
 				throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
@@ -705,6 +526,168 @@ public abstract class ReflectionUtils {
 		return result;
 	}
 
+	/**
+	 * Determine whether the given method is an "equals" method.
+	 * @see java.lang.Object#equals(Object)
+	 */
+	public static boolean isEqualsMethod(@Nullable Method method) {
+		if (method == null || !method.getName().equals("equals")) {
+			return false;
+		}
+		Class<?>[] paramTypes = method.getParameterTypes();
+		return (paramTypes.length == 1 && paramTypes[0] == Object.class);
+	}
+
+	/**
+	 * Determine whether the given method is a "hashCode" method.
+	 * @see java.lang.Object#hashCode()
+	 */
+	public static boolean isHashCodeMethod(@Nullable Method method) {
+		return (method != null && method.getName().equals("hashCode") && method.getParameterCount() == 0);
+	}
+
+	/**
+	 * Determine whether the given method is a "toString" method.
+	 * @see java.lang.Object#toString()
+	 */
+	public static boolean isToStringMethod(@Nullable Method method) {
+		return (method != null && method.getName().equals("toString") && method.getParameterCount() == 0);
+	}
+
+	/**
+	 * Determine whether the given method is originally declared by {@link java.lang.Object}.
+	 */
+	public static boolean isObjectMethod(@Nullable Method method) {
+		if (method == null) {
+			return false;
+		}
+		try {
+			Object.class.getDeclaredMethod(method.getName(), method.getParameterTypes());
+			return true;
+		}
+		catch (Exception ex) {
+			return false;
+		}
+	}
+
+	/**
+	 * Determine whether the given method is a CGLIB 'renamed' method,
+	 * following the pattern "CGLIB$methodName$0".
+	 * @param renamedMethod the method to check
+	 */
+	public static boolean isCglibRenamedMethod(Method renamedMethod) {
+		String name = renamedMethod.getName();
+		if (name.startsWith(CGLIB_RENAMED_METHOD_PREFIX)) {
+			int i = name.length() - 1;
+			while (i >= 0 && Character.isDigit(name.charAt(i))) {
+				i--;
+			}
+			return (i > CGLIB_RENAMED_METHOD_PREFIX.length() && (i < name.length() - 1) && name.charAt(i) == '$');
+		}
+		return false;
+	}
+
+	/**
+	 * Make the given method accessible, explicitly setting it accessible if
+	 * necessary. The {@code setAccessible(true)} method is only called
+	 * when actually necessary, to avoid unnecessary conflicts with a JVM
+	 * SecurityManager (if active).
+	 * @param method the method to make accessible
+	 * @see java.lang.reflect.Method#setAccessible
+	 */
+	@SuppressWarnings("deprecation")  // on JDK 9
+	public static void makeAccessible(Method method) {
+		if ((!Modifier.isPublic(method.getModifiers()) ||
+				!Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) {
+			method.setAccessible(true);
+		}
+	}
+
+
+	// Field handling
+
+	/**
+	 * Attempt to find a {@link Field field} on the supplied {@link Class} with the
+	 * supplied {@code name}. Searches all superclasses up to {@link Object}.
+	 * @param clazz the class to introspect
+	 * @param name the name of the field
+	 * @return the corresponding Field object, or {@code null} if not found
+	 */
+	@Nullable
+	public static Field findField(Class<?> clazz, String name) {
+		return findField(clazz, name, null);
+	}
+
+	/**
+	 * Attempt to find a {@link Field field} on the supplied {@link Class} with the
+	 * supplied {@code name} and/or {@link Class type}. Searches all superclasses
+	 * up to {@link Object}.
+	 * @param clazz the class to introspect
+	 * @param name the name of the field (may be {@code null} if type is specified)
+	 * @param type the type of the field (may be {@code null} if name is specified)
+	 * @return the corresponding Field object, or {@code null} if not found
+	 */
+	@Nullable
+	public static Field findField(Class<?> clazz, @Nullable String name, @Nullable Class<?> type) {
+		Assert.notNull(clazz, "Class must not be null");
+		Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
+		Class<?> searchType = clazz;
+		while (Object.class != searchType && searchType != null) {
+			Field[] fields = getDeclaredFields(searchType);
+			for (Field field : fields) {
+				if ((name == null || name.equals(field.getName())) &&
+						(type == null || type.equals(field.getType()))) {
+					return field;
+				}
+			}
+			searchType = searchType.getSuperclass();
+		}
+		return null;
+	}
+
+	/**
+	 * Set the field represented by the supplied {@link Field field object} on the
+	 * specified {@link Object target object} to the specified {@code value}.
+	 * In accordance with {@link Field#set(Object, Object)} semantics, the new value
+	 * is automatically unwrapped if the underlying field has a primitive type.
+	 * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
+	 * @param field the field to set
+	 * @param target the target object on which to set the field
+	 * @param value the value to set (may be {@code null})
+	 */
+	public static void setField(Field field, @Nullable Object target, @Nullable Object value) {
+		try {
+			field.set(target, value);
+		}
+		catch (IllegalAccessException ex) {
+			handleReflectionException(ex);
+			throw new IllegalStateException(
+					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
+		}
+	}
+
+	/**
+	 * Get the field represented by the supplied {@link Field field object} on the
+	 * specified {@link Object target object}. In accordance with {@link Field#get(Object)}
+	 * semantics, the returned value is automatically wrapped if the underlying field
+	 * has a primitive type.
+	 * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
+	 * @param field the field to get
+	 * @param target the target object from which to get the field
+	 * @return the field's current value
+	 */
+	@Nullable
+	public static Object getField(Field field, @Nullable Object target) {
+		try {
+			return field.get(target);
+		}
+		catch (IllegalAccessException ex) {
+			handleReflectionException(ex);
+			throw new IllegalStateException(
+					"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
+		}
+	}
+
 	/**
 	 * Invoke the given callback on all locally declared fields in the given class.
 	 * @param clazz the target class to analyze
@@ -778,7 +761,7 @@ public abstract class ReflectionUtils {
 		if (result == null) {
 			try {
 				result = clazz.getDeclaredFields();
-				declaredFieldsCache.put(clazz, (result.length == 0 ? NO_FIELDS : result));
+				declaredFieldsCache.put(clazz, (result.length == 0 ? EMPTY_FIELD_ARRAY : result));
 			}
 			catch (Throwable ex) {
 				throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
@@ -808,6 +791,35 @@ public abstract class ReflectionUtils {
 		}, COPYABLE_FIELDS);
 	}
 
+	/**
+	 * Determine whether the given field is a "public static final" constant.
+	 * @param field the field to check
+	 */
+	public static boolean isPublicStaticFinal(Field field) {
+		int modifiers = field.getModifiers();
+		return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
+	}
+
+	/**
+	 * Make the given field accessible, explicitly setting it accessible if
+	 * necessary. The {@code setAccessible(true)} method is only called
+	 * when actually necessary, to avoid unnecessary conflicts with a JVM
+	 * SecurityManager (if active).
+	 * @param field the field to make accessible
+	 * @see java.lang.reflect.Field#setAccessible
+	 */
+	@SuppressWarnings("deprecation")  // on JDK 9
+	public static void makeAccessible(Field field) {
+		if ((!Modifier.isPublic(field.getModifiers()) ||
+				!Modifier.isPublic(field.getDeclaringClass().getModifiers()) ||
+				Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
+			field.setAccessible(true);
+		}
+	}
+
+
+	// Cache handling
+
 	/**
 	 * Clear the internal method/field cache.
 	 * @since 4.2.4

spring-tx/src/main/java/org/springframework/transaction/interceptor/CompositeTransactionAttributeSource.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.
@@ -39,7 +39,7 @@ public class CompositeTransactionAttributeSource implements TransactionAttribute
 	 * Create a new CompositeTransactionAttributeSource for the given sources.
 	 * @param transactionAttributeSources the TransactionAttributeSource instances to combine
 	 */
-	public CompositeTransactionAttributeSource(TransactionAttributeSource[] transactionAttributeSources) {
+	public CompositeTransactionAttributeSource(TransactionAttributeSource... transactionAttributeSources) {
 		Assert.notNull(transactionAttributeSources, "TransactionAttributeSource array must not be null");
 		this.transactionAttributeSources = transactionAttributeSources;
 	}
@@ -56,10 +56,10 @@ public class CompositeTransactionAttributeSource implements TransactionAttribute
 	@Override
 	@Nullable
 	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
-		for (TransactionAttributeSource tas : this.transactionAttributeSources) {
+		for (TransactionAttributeSource source : this.transactionAttributeSources) {
-			TransactionAttribute ta = tas.getTransactionAttribute(method, targetClass);
+			TransactionAttribute attr = source.getTransactionAttribute(method, targetClass);
-			if (ta != null) {
+			if (attr != null) {
-				return ta;
+				return attr;
 			}
 		}
 		return null;

spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeSource.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.
@@ -27,6 +27,7 @@ import org.springframework.lang.Nullable;
  * metadata attributes at source level (such as Java 5 annotations), or anywhere else.
  *
  * @author Rod Johnson
+ * @author Juergen Hoeller
  * @since 15.04.2003
  * @see TransactionInterceptor#setTransactionAttributeSource
  * @see TransactionProxyFactoryBean#setTransactionAttributeSource
@@ -40,8 +41,7 @@ public interface TransactionAttributeSource {
 	 * @param method the method to introspect
 	 * @param targetClass the target class (may be {@code null},
 	 * in which case the declaring class of the method must be used)
-	 * @return the TransactionAttribute the matching transaction attribute,
+	 * @return the matching transaction attribute, or {@code null} if none found
-	 * or {@code null} if none found
 	 */
 	@Nullable
 	TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass);

spring-web/src/main/java/org/springframework/http/server/ServerHttpRequest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 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.
@@ -21,6 +21,7 @@ import java.security.Principal;
 
 import org.springframework.http.HttpInputMessage;
 import org.springframework.http.HttpRequest;
+import org.springframework.lang.Nullable;
 
 /**
  * Represents a server-side HTTP request.
@@ -33,9 +34,10 @@ public interface ServerHttpRequest extends HttpRequest, HttpInputMessage {
 
 	/**
 	 * Return a {@link java.security.Principal} instance containing the name of the
-	 * authenticated user. If the user has not been authenticated, the method returns
+	 * authenticated user.
-	 * <code>null</code>.
+	 * <p>If the user has not been authenticated, the method returns <code>null</code>.
 	 */
+	@Nullable
 	Principal getPrincipal();
 
 	/**