MethodParameter supports Java 8 Executable/Parameter and validates parameter indexes

Also, equals insists on the same class now, differentiating from SynthesizingMethodParameter.

Issue: SPR-14055
Issue: SPR-13456
Issue: SPR-14438

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/factory/support/ConstructorResolver.java

@@ -18,7 +18,7 @@
 
 import java.beans.ConstructorProperties;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Member;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.security.AccessController;
@@ -506,7 +506,7 @@ public BeanWrapper instantiateUsingFactoryMethod(
 					// and explicitly ignore overridden methods (with the same parameter signature).
 					else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
 							!mbd.isLenientConstructorResolution() &&
-							paramTypes.length == factoryMethodToUse.getParameterTypes().length &&
+							paramTypes.length == factoryMethodToUse.getParameterCount() &&
 							!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
 						if (ambiguousFactoryMethods == null) {
 							ambiguousFactoryMethods = new LinkedHashSet<>();
@@ -662,7 +662,7 @@ private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd,
 	 */
 	private ArgumentsHolder createArgumentArray(
 			String beanName, RootBeanDefinition mbd, ConstructorArgumentValues resolvedValues,
-			BeanWrapper bw, Class<?>[] paramTypes, String[] paramNames, Object methodOrCtor,
+			BeanWrapper bw, Class<?>[] paramTypes, String[] paramNames, Executable executable,
 			boolean autowiring) throws UnsatisfiedDependencyException {
 
 		TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
@@ -699,7 +699,7 @@ private ArgumentsHolder createArgumentArray(
 					ConstructorArgumentValues.ValueHolder sourceHolder =
 							(ConstructorArgumentValues.ValueHolder) valueHolder.getSource();
 					Object sourceValue = sourceHolder.getValue();
-					MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, paramIndex);
+					MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
 					try {
 						convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
 						// TODO re-enable once race condition has been found (SPR-7423)
@@ -727,7 +727,7 @@ private ArgumentsHolder createArgumentArray(
 				args.rawArguments[paramIndex] = originalValue;
 			}
 			else {
-				MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, paramIndex);
+				MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
 				// No explicit match found: we're either supposed to autowire or
 				// have to fail creating an argument array for the given constructor.
 				if (!autowiring) {
@@ -755,7 +755,7 @@ private ArgumentsHolder createArgumentArray(
 			this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
 			if (this.beanFactory.logger.isDebugEnabled()) {
 				this.beanFactory.logger.debug("Autowiring by type from bean name '" + beanName +
-						"' via " + (methodOrCtor instanceof Constructor ? "constructor" : "factory method") +
+						"' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
 						" to bean named '" + autowiredBeanName + "'");
 			}
 		}
@@ -767,19 +767,18 @@ private ArgumentsHolder createArgumentArray(
 	 * Resolve the prepared arguments stored in the given bean definition.
 	 */
 	private Object[] resolvePreparedArguments(
-			String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {
+			String beanName, RootBeanDefinition mbd, BeanWrapper bw, Executable executable, Object[] argsToResolve) {
 
-		Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
-				((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
+		Class<?>[] paramTypes = executable.getParameterTypes();
 		TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
 				this.beanFactory.getCustomTypeConverter() : bw);
 		BeanDefinitionValueResolver valueResolver =
 				new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
 		Object[] resolvedArgs = new Object[argsToResolve.length];
 		for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
 			Object argValue = argsToResolve[argIndex];
-			MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
-			GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
+			MethodParameter methodParam = MethodParameter.forExecutable(executable, argIndex);
+			GenericTypeResolver.resolveParameterType(methodParam, executable.getDeclaringClass());
 			if (argValue instanceof AutowiredArgumentMarker) {
 				argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
 			}

spring-core/src/main/java/org/springframework/core/MethodParameter.java

@@ -19,8 +19,10 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.HashMap;
@@ -54,6 +56,8 @@ public class MethodParameter {
 
 	private final int parameterIndex;
 
+	private volatile Parameter parameter;
+
 	private int nestingLevel = 1;
 
 	/** Map from Integer level to Integer type index */
@@ -98,7 +102,7 @@ public MethodParameter(Method method, int parameterIndex) {
 	public MethodParameter(Method method, int parameterIndex, int nestingLevel) {
 		Assert.notNull(method, "Method must not be null");
 		this.method = method;
-		this.parameterIndex = parameterIndex;
+		this.parameterIndex = validateIndex(method, parameterIndex);
 		this.nestingLevel = nestingLevel;
 		this.constructor = null;
 	}
@@ -123,7 +127,7 @@ public MethodParameter(Constructor<?> constructor, int parameterIndex) {
 	public MethodParameter(Constructor<?> constructor, int parameterIndex, int nestingLevel) {
 		Assert.notNull(constructor, "Constructor must not be null");
 		this.constructor = constructor;
-		this.parameterIndex = parameterIndex;
+		this.parameterIndex = validateIndex(constructor, parameterIndex);
 		this.nestingLevel = nestingLevel;
 		this.method = null;
 	}
@@ -138,6 +142,7 @@ public MethodParameter(MethodParameter original) {
 		this.method = original.method;
 		this.constructor = original.constructor;
 		this.parameterIndex = original.parameterIndex;
+		this.parameter = original.parameter;
 		this.nestingLevel = original.nestingLevel;
 		this.typeIndexesPerLevel = original.typeIndexesPerLevel;
 		this.containingClass = original.containingClass;
@@ -179,15 +184,7 @@ public Class<?> getDeclaringClass() {
 	 * @return the Method or Constructor as Member
 	 */
 	public Member getMember() {
-		// NOTE: no ternary expression to retain JDK <8 compatibility even when using
-		// the JDK 8 compiler (potentially selecting java.lang.reflect.Executable
-		// as common type, with that new base class not available on older JDKs)
-		if (this.method != null) {
-			return this.method;
-		}
-		else {
-			return this.constructor;
-		}
+		return getExecutable();
 	}
 
 	/**
@@ -197,15 +194,27 @@ public Member getMember() {
 	 * @return the Method or Constructor as AnnotatedElement
 	 */
 	public AnnotatedElement getAnnotatedElement() {
-		// NOTE: no ternary expression to retain JDK <8 compatibility even when using
-		// the JDK 8 compiler (potentially selecting java.lang.reflect.Executable
-		// as common type, with that new base class not available on older JDKs)
-		if (this.method != null) {
-			return this.method;
-		}
-		else {
-			return this.constructor;
+		return getExecutable();
+	}
+
+	/**
+	 * Return the wrapped executable.
+	 * @return the Method or Constructor as Executable
+	 * @since 5.0
+	 */
+	public Executable getExecutable() {
+		return (this.method != null ? this.method : this.constructor);
+	}
+
+	/**
+	 * Return the {@link Parameter} descriptor for method/constructor parameter.
+	 * @since 5.0
+	 */
+	public Parameter getParameter() {
+		if (this.parameter == null) {
+			this.parameter = getExecutable().getParameters()[this.parameterIndex];
 		}
+		return this.parameter;
 	}
 
 	/**
@@ -570,11 +579,11 @@ public boolean equals(Object other) {
 		if (this == other) {
 			return true;
 		}
-		if (!(other instanceof MethodParameter)) {
+		if (other == null || getClass() != other.getClass()) {
 			return false;
 		}
 		MethodParameter otherParam = (MethodParameter) other;
-		return (this.parameterIndex == otherParam.parameterIndex && getMember().equals(otherParam.getMember()));
+		return (this.parameterIndex == otherParam.parameterIndex && getExecutable().equals(otherParam.getExecutable()));
 	}
 
 	@Override
@@ -596,23 +605,73 @@ public MethodParameter clone() {
 
 	/**
 	 * Create a new MethodParameter for the given method or constructor.
-	 * <p>This is a convenience constructor for scenarios where a
+	 * <p>This is a convenience factory method for scenarios where a
 	 * Method or Constructor reference is treated in a generic fashion.
 	 * @param methodOrConstructor the Method or Constructor to specify a parameter for
 	 * @param parameterIndex the index of the parameter
 	 * @return the corresponding MethodParameter instance
+	 * @deprecated as of 5.0, in favor of {@link #forExecutable}
 	 */
+	@Deprecated
 	public static MethodParameter forMethodOrConstructor(Object methodOrConstructor, int parameterIndex) {
-		if (methodOrConstructor instanceof Method) {
-			return new MethodParameter((Method) methodOrConstructor, parameterIndex);
+		if (!(methodOrConstructor instanceof Executable)) {
+			throw new IllegalArgumentException(
+					"Given object [" + methodOrConstructor + "] is neither a Method nor a Constructor");
 		}
-		else if (methodOrConstructor instanceof Constructor) {
-			return new MethodParameter((Constructor<?>) methodOrConstructor, parameterIndex);
+		return forExecutable((Executable) methodOrConstructor, parameterIndex);
+	}
+
+	/**
+	 * Create a new MethodParameter for the given method or constructor.
+	 * <p>This is a convenience factory method for scenarios where a
+	 * Method or Constructor reference is treated in a generic fashion.
+	 * @param executable the Method or Constructor to specify a parameter for
+	 * @param parameterIndex the index of the parameter
+	 * @return the corresponding MethodParameter instance
+	 * @since 5.0
+	 */
+	public static MethodParameter forExecutable(Executable executable, int parameterIndex) {
+		if (executable instanceof Method) {
+			return new MethodParameter((Method) executable, parameterIndex);
+		}
+		else if (executable instanceof Constructor) {
+			return new MethodParameter((Constructor<?>) executable, parameterIndex);
 		}
 		else {
-			throw new IllegalArgumentException(
-					"Given object [" + methodOrConstructor + "] is neither a Method nor a Constructor");
+			throw new IllegalArgumentException("Not a Method/Constructor: " + executable);
+		}
+	}
+
+	/**
+	 * Create a new MethodParameter for the given parameter descriptor.
+	 * <p>This is a convenience factory method for scenarios where a
+	 * Java 8 {@link Parameter} descriptor is already available.
+	 * @param parameter the parameter descriptor
+	 * @return the corresponding MethodParameter instance
+	 * @since 5.0
+	 */
+	public static MethodParameter forParameter(Parameter parameter) {
+		return forExecutable(parameter.getDeclaringExecutable(), findParameterIndex(parameter));
+	}
+
+	protected static int findParameterIndex(Parameter parameter) {
+		Executable executable = parameter.getDeclaringExecutable();
+		Parameter[] allParams = executable.getParameters();
+		for (int i = 0; i < allParams.length; i++) {
+			if (parameter == allParams[i]) {
+				return i;
+			}
+		}
+		throw new IllegalArgumentException("Given parameter [" + parameter +
+				"] does not match any parameter in the declaring executable");
+	}
+
+	private static int validateIndex(Executable executable, int parameterIndex) {
+		int count = executable.getParameterCount();
+		if (parameterIndex >= count) {
+			throw new IllegalArgumentException("Parameter index needs to be between 0 and " + (count - 1));
 		}
+		return parameterIndex;
 	}
 
 }

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

@@ -18,7 +18,9 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
 
 import org.springframework.core.MethodParameter;
 
@@ -108,4 +110,38 @@ public SynthesizingMethodParameter clone() {
 		return new SynthesizingMethodParameter(this);
 	}
 
+
+	/**
+	 * Create a new SynthesizingMethodParameter for the given method or constructor.
+	 * <p>This is a convenience factory method for scenarios where a
+	 * Method or Constructor reference is treated in a generic fashion.
+	 * @param executable the Method or Constructor to specify a parameter for
+	 * @param parameterIndex the index of the parameter
+	 * @return the corresponding SynthesizingMethodParameter instance
+	 * @since 5.0
+	 */
+	public static SynthesizingMethodParameter forExecutable(Executable executable, int parameterIndex) {
+		if (executable instanceof Method) {
+			return new SynthesizingMethodParameter((Method) executable, parameterIndex);
+		}
+		else if (executable instanceof Constructor) {
+			return new SynthesizingMethodParameter((Constructor<?>) executable, parameterIndex);
+		}
+		else {
+			throw new IllegalArgumentException("Not a Method/Constructor: " + executable);
+		}
+	}
+
+	/**
+	 * Create a new SynthesizingMethodParameter for the given parameter descriptor.
+	 * <p>This is a convenience factory method for scenarios where a
+	 * Java 8 {@link Parameter} descriptor is already available.
+	 * @param parameter the parameter descriptor
+	 * @return the corresponding SynthesizingMethodParameter instance
+	 * @since 5.0
+	 */
+	public static SynthesizingMethodParameter forParameter(Parameter parameter) {
+		return forExecutable(parameter.getDeclaringExecutable(), findParameterIndex(parameter));
+	}
+
 }

spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java

@@ -158,7 +158,7 @@ public void getRawMapTypeCannotBeResolved() throws Exception {
 	@Test
 	public void getGenericsOnArrayFromParamCannotBeResolved() throws Exception {
 		// SPR-11044
-		MethodParameter methodParameter = MethodParameter.forMethodOrConstructor(
+		MethodParameter methodParameter = MethodParameter.forExecutable(
 				WithArrayBase.class.getDeclaredMethod("array", Object[].class), 0);
 		Class<?> resolved = GenericTypeResolver.resolveParameterType(methodParameter, WithArray.class);
 		assertThat(resolved, equalTo((Class<?>) Object[].class));