Support for populating model attributes through data class constructors

Includes a new overloaded ModelAndView constructor with an HttpStatus argument, as well as a HandlerMethodArgumentResolverSupport refactoring (revised checkParameterType signature, actually implementing the HandlerMethodArgumentResolver interface).

Issue: SPR-15199

Author: jhoeller

spring-web/src/main/java/org/springframework/web/method/annotation/ModelAttributeMethodProcessor.java

@@ -16,15 +16,20 @@
 
 package org.springframework.web.method.annotation;
 
+import java.beans.ConstructorProperties;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
 import java.util.Map;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.beans.BeanUtils;
+import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.MethodParameter;
+import org.springframework.core.ParameterNameDiscoverer;
 import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.util.Assert;
 import org.springframework.validation.BindException;
 import org.springframework.validation.Errors;
 import org.springframework.validation.annotation.Validated;
@@ -52,10 +57,13 @@
  * attribute with or without the presence of an {@code @ModelAttribute}.
  *
  * @author Rossen Stoyanchev
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {
 
+	private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
+
 	protected final Log logger = LogFactory.getLog(getClass());
 
 	private final boolean annotationNotRequired;
@@ -65,7 +73,7 @@ public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResol
 	 * Class constructor.
 	 * @param annotationNotRequired if "true", non-simple method arguments and
 	 * return values are considered model attributes with or without a
-	 * {@code @ModelAttribute} annotation.
+	 * {@code @ModelAttribute} annotation
 	 */
 	public ModelAttributeMethodProcessor(boolean annotationNotRequired) {
 		this.annotationNotRequired = annotationNotRequired;
@@ -89,8 +97,8 @@ public boolean supportsParameter(MethodParameter parameter) {
 	 * with request values via data binding and optionally validated
 	 * if {@code @java.validation.Valid} is present on the argument.
 	 * @throws BindException if data binding and validation result in an error
-	 * and the next method parameter is not of type {@link Errors}.
-	 * @throws Exception if WebDataBinder initialization fails.
+	 * and the next method parameter is not of type {@link Errors}
+	 * @throws Exception if WebDataBinder initialization fails
 	 */
 	@Override
 	public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
@@ -123,22 +131,54 @@ public final Object resolveArgument(MethodParameter parameter, ModelAndViewConta
 		mavContainer.removeAttributes(bindingResultModel);
 		mavContainer.addAllAttributes(bindingResultModel);
 
-		return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
+		return (parameter.getParameterType().isInstance(attribute) ? attribute :
+				binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter));
 	}
 
 	/**
-	 * Extension point to create the model attribute if not found in the model.
-	 * The default implementation uses the default constructor.
+	 * Extension point to create the model attribute if not found in the model,
+	 * with subsequent parameter binding through bean properties (unless suppressed).
+	 * <p>The default implementation uses the unique public no-arg constructor, if any,
+	 * which may have arguments: It understands the JavaBeans {@link ConstructorProperties}
+	 * annotation as well as runtime-retained parameter names in the bytecode,
+	 * associating request parameters with constructor arguments by name. If no such
+	 * constructor is found, the default constructor will be used (even if not public),
+	 * assuming subsequent bean property bindings through setter methods.
 	 * @param attributeName the name of the attribute (never {@code null})
-	 * @param methodParam the method parameter
+	 * @param parameter the method parameter declaration
 	 * @param binderFactory for creating WebDataBinder instance
-	 * @param request the current request
+	 * @param webRequest the current request
 	 * @return the created model attribute (never {@code null})
 	 */
-	protected Object createAttribute(String attributeName, MethodParameter methodParam,
-			WebDataBinderFactory binderFactory, NativeWebRequest request) throws Exception {
+	protected Object createAttribute(String attributeName, MethodParameter parameter,
+			WebDataBinderFactory binderFactory, NativeWebRequest webRequest) throws Exception {
+
+		Constructor<?>[] ctors = parameter.getParameterType().getConstructors();
+		if (ctors.length != 1) {
+			// No standard data class or standard JavaBeans arrangement ->
+			// defensively go with default constructor, expecting regular bean property bindings.
+			return BeanUtils.instantiateClass(parameter.getParameterType());
+		}
+		Constructor<?> ctor = ctors[0];
+		if (ctor.getParameterCount() == 0) {
+			// A single default constructor -> clearly a standard JavaBeans arrangement.
+			return BeanUtils.instantiateClass(ctor);
+		}
 
-		return BeanUtils.instantiateClass(methodParam.getParameterType());
+		// A single data class constructor -> resolve constructor arguments from request parameters.
+		ConstructorProperties cp = ctor.getAnnotation(ConstructorProperties.class);
+		String[] paramNames = (cp != null ? cp.value() : parameterNameDiscoverer.getParameterNames(ctor));
+		Assert.state(paramNames != null, () -> "Cannot resolve parameter names for constructor " + ctor);
+		Class<?>[] paramTypes = ctor.getParameterTypes();
+		Assert.state(paramNames.length == paramTypes.length,
+				() -> "Invalid number of parameter names: " + paramNames.length + " for constructor " + ctor);
+		Object[] args = new Object[paramTypes.length];
+		WebDataBinder binder = binderFactory.createBinder(webRequest, null, attributeName);
+		for (int i = 0; i < paramNames.length; i++) {
+			args[i] = binder.convertIfNecessary(
+					webRequest.getParameterValues(paramNames[i]), paramTypes[i], new MethodParameter(ctor, i));
+		}
+		return BeanUtils.instantiateClass(ctor, args);
 	}
 
 	/**
@@ -156,10 +196,10 @@ protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest requ
 	 * Spring's {@link org.springframework.validation.annotation.Validated},
 	 * and custom annotations whose name starts with "Valid".
 	 * @param binder the DataBinder to be used
-	 * @param methodParam the method parameter
+	 * @param parameter the method parameter declaration
 	 */
-	protected void validateIfApplicable(WebDataBinder binder, MethodParameter methodParam) {
-		Annotation[] annotations = methodParam.getParameterAnnotations();
+	protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
+		Annotation[] annotations = parameter.getParameterAnnotations();
 		for (Annotation ann : annotations) {
 			Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
 			if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
@@ -174,12 +214,12 @@ protected void validateIfApplicable(WebDataBinder binder, MethodParameter method
 	/**
 	 * Whether to raise a fatal bind exception on validation errors.
 	 * @param binder the data binder used to perform data binding
-	 * @param methodParam the method argument
+	 * @param parameter the method parameter declaration
 	 * @return {@code true} if the next method argument is not of type {@link Errors}
 	 */
-	protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter methodParam) {
-		int i = methodParam.getParameterIndex();
-		Class<?>[] paramTypes = methodParam.getMethod().getParameterTypes();
+	protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter parameter) {
+		int i = parameter.getParameterIndex();
+		Class<?>[] paramTypes = parameter.getMethod().getParameterTypes();
 		boolean hasBindingResult = (paramTypes.length > (i + 1) && Errors.class.isAssignableFrom(paramTypes[i + 1]));
 		return !hasBindingResult;
 	}

spring-web/src/test/java/org/springframework/web/method/annotation/ModelAttributeMethodProcessorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2017 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.
@@ -70,7 +70,7 @@ public class ModelAttributeMethodProcessorTests {
 
 
 	@Before
-	public void setUp() throws Exception {
+	public void setup() throws Exception {
 		this.request = new ServletWebRequest(new MockHttpServletRequest());
 		this.container = new ModelAndViewContainer();
 		this.processor = new ModelAttributeMethodProcessor(false);
@@ -145,7 +145,7 @@ public void resolveArgumentFromModel() throws Exception {
 	}
 
 	@Test
-	public void resovleArgumentViaDefaultConstructor() throws Exception {
+	public void resolveArgumentViaDefaultConstructor() throws Exception {
 		WebDataBinder dataBinder = new WebRequestDataBinder(null);
 		WebDataBinderFactory factory = mock(WebDataBinderFactory.class);
 		given(factory.createBinder(any(), notNull(), eq("attrName"))).willReturn(dataBinder);

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

@@ -44,7 +44,7 @@ public interface HandlerMethodArgumentResolver {
 	 * @param exchange the current exchange
 	 * @return {@code Mono} for the argument value, possibly empty
 	 */
-	Mono<Object> resolveArgument(MethodParameter parameter, BindingContext bindingContext,
-			ServerWebExchange exchange);
+	Mono<Object> resolveArgument(
+			MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange);
 
 }

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.web.reactive.result.method;
 
 import java.lang.annotation.Annotation;
@@ -25,14 +26,14 @@
 import org.springframework.util.Assert;
 
 /**
- * Base class for {@link HandlerMethodArgumentResolver} implementations with
- * access to a {@code ReactiveAdapterRegistry} and methods to check for
- * method parameter support.
+ * Base class for {@link HandlerMethodArgumentResolver} implementations with access to a
+ * {@code ReactiveAdapterRegistry} and methods to check for method parameter support.
  *
  * @author Rossen Stoyanchev
+ * @author Juergen Hoeller
  * @since 5.0
  */
-public abstract class HandlerMethodArgumentResolverSupport {
+public abstract class HandlerMethodArgumentResolverSupport implements HandlerMethodArgumentResolver {
 
 	private final ReactiveAdapterRegistry adapterRegistry;
 
@@ -55,12 +56,12 @@ public ReactiveAdapterRegistry getAdapterRegistry() {
 	 * Evaluate the {@code Predicate} on the the method parameter type or on
 	 * the generic type within a reactive type wrapper.
 	 */
-	protected boolean checkParamType(MethodParameter param, Predicate<Class<?>> predicate) {
-		Class<?> type = param.getParameterType();
+	protected boolean checkParameterType(MethodParameter parameter, Predicate<Class<?>> predicate) {
+		Class<?> type = parameter.getParameterType();
 		ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
 		if (adapter != null) {
-			assertHasValues(adapter, param);
-			type = param.nested().getNestedParameterType();
+			assertHasValues(adapter, parameter);
+			type = parameter.nested().getNestedParameterType();
 		}
 		return predicate.test(type);
 	}
@@ -77,25 +78,25 @@ private void assertHasValues(ReactiveAdapter adapter, MethodParameter param) {
 	 * {@code IllegalStateException} if the same matches the generic type
 	 * within a reactive type wrapper.
 	 */
-	protected boolean checkParamTypeNoReactiveWrapper(MethodParameter param, Predicate<Class<?>> predicate) {
-		Class<?> type = param.getParameterType();
+	protected boolean checkParameterTypeNoReactiveWrapper(MethodParameter parameter, Predicate<Class<?>> predicate) {
+		Class<?> type = parameter.getParameterType();
 		ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
 		if (adapter != null) {
-			assertHasValues(adapter, param);
-			type = param.nested().getNestedParameterType();
+			assertHasValues(adapter, parameter);
+			type = parameter.nested().getNestedParameterType();
 		}
 		if (predicate.test(type)) {
 			if (adapter == null) {
 				return true;
 			}
-			throw getReactiveWrapperError(param);
+			throw buildReactiveWrapperException(parameter);
 		}
 		return false;
 	}
 
-	private IllegalStateException getReactiveWrapperError(MethodParameter param) {
+	private IllegalStateException buildReactiveWrapperException(MethodParameter parameter) {
 		return new IllegalStateException(getClass().getSimpleName() +
-				" doesn't support reactive type wrapper: " + param.getGenericParameterType());
+				" doesn't support reactive type wrapper: " + parameter.getGenericParameterType());
 	}
 
 	/**
@@ -105,29 +106,28 @@ private IllegalStateException getReactiveWrapperError(MethodParameter param) {
 	 * type within a reactive type wrapper.
 	 */
 	protected <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapper(
-			MethodParameter param, Class<A> annotationType,
-			BiPredicate<A, Class<?>> typePredicate) {
+			MethodParameter parameter, Class<A> annotationType, BiPredicate<A, Class<?>> typePredicate) {
 
-		A annotation = param.getParameterAnnotation(annotationType);
+		A annotation = parameter.getParameterAnnotation(annotationType);
 		if (annotation == null) {
 			return false;
 		}
 
-		param = param.nestedIfOptional();
-		Class<?> type = param.getNestedParameterType();
+		parameter = parameter.nestedIfOptional();
+		Class<?> type = parameter.getNestedParameterType();
 
 		ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
 		if (adapter != null) {
-			assertHasValues(adapter, param);
-			param = param.nested();
-			type = param.getNestedParameterType();
+			assertHasValues(adapter, parameter);
+			parameter = parameter.nested();
+			type = parameter.getNestedParameterType();
 		}
 
 		if (typePredicate.test(annotation, type)) {
 			if (adapter == null) {
 				return true;
 			}
-			throw getReactiveWrapperError(param);
+			throw buildReactiveWrapperException(parameter);
 		}
 
 		return false;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2017 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.
@@ -33,15 +33,14 @@
  */
 public interface SyncHandlerMethodArgumentResolver extends HandlerMethodArgumentResolver {
 
-
 	/**
 	 * {@inheritDoc}
 	 * <p>By default this simply delegates to {@link #resolveArgumentValue} for
 	 * synchronous resolution.
 	 */
 	@Override
-	default Mono<Object> resolveArgument(MethodParameter parameter, BindingContext bindingContext,
-			ServerWebExchange exchange) {
+	default Mono<Object> resolveArgument(
+			MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) {
 
 		return Mono.justOrEmpty(resolveArgumentValue(parameter, bindingContext, exchange));
 	}
@@ -53,7 +52,7 @@ default Mono<Object> resolveArgument(MethodParameter parameter, BindingContext b
 	 * @param exchange the current exchange
 	 * @return an {@code Optional} with the resolved value, possibly empty
 	 */
-	Optional<Object> resolveArgumentValue(MethodParameter parameter, BindingContext bindingContext,
-			ServerWebExchange exchange);
+	Optional<Object> resolveArgumentValue(
+			MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange);
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2017 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.
@@ -114,7 +114,6 @@ protected Mono<Object> readBody(MethodParameter bodyParameter, boolean isBodyReq
 		}
 
 		for (ServerHttpMessageReader<?> reader : getMessageReaders()) {
-
 			if (reader.canRead(elementType, mediaType)) {
 				Map<String, Object> readHints = Collections.emptyMap();
 				if (adapter != null && adapter.isMultiValue()) {
@@ -171,9 +170,9 @@ private ServerWebInputException getRequiredBodyError(MethodParameter parameter)
 	private Object[] extractValidationHints(MethodParameter parameter) {
 		Annotation[] annotations = parameter.getParameterAnnotations();
 		for (Annotation ann : annotations) {
-			Validated validAnnot = AnnotationUtils.getAnnotation(ann, Validated.class);
-			if (validAnnot != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
-				Object hints = (validAnnot != null ? validAnnot.value() : AnnotationUtils.getValue(ann));
+			Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
+			if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
+				Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
 				return (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
 			}
 		}