Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SPR-7608 Add fallback mechanism for instantiating a model attribute from a path variable

Browse Source
This commit is contained in:
Rossen Stoyanchev
2011-06-24 17:18:53 +00:00
parent 8e240d814b
commit 1e07af8827
5 changed files with 268 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
org.springframework.web/src/main/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessor.java
View File

@@ -18,11 +18,12 @@ package org.springframework.web.method.annotation.support;
import java.lang.annotation.Annotation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.core.MethodParameter;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.DataBinder;
import org.springframework.validation.Errors;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
@@ -50,6 +51,8 @@ import org.springframework.web.method.support.ModelAndViewContainer;
*/
public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {
protected Log logger = LogFactory.getLog(this.getClass());
private final boolean useDefaultResolution;
/**
@@ -82,24 +85,31 @@ public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResol
* default constructor. Data binding and optionally validation is then applied through a {@link WebDataBinder}
* instance. Validation is invoked optionally when the method parameter is annotated with an {@code @Valid}.
*
* @throws Exception if a {@link WebDataBinder} could not be created or if data binding and validation result in
* an error and the next method parameter is not of type {@link Errors} or {@link BindingResult}.
* @throws BindException if data binding and validation result in an error and the next method parameter
* is neither of type {@link Errors} nor {@link BindingResult}.
* @throws Exception if a {@link WebDataBinder} could not be created.
*/
public final Object resolveArgument(MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest,
NativeWebRequest request,
WebDataBinderFactory binderFactory) throws Exception {
WebDataBinder binder = createDataBinder(parameter, mavContainer, webRequest, binderFactory);
String name = ModelFactory.getNameForParameter(parameter);
Object target = (mavContainer.containsAttribute(name)) ?
mavContainer.getAttribute(name) : createAttribute(name, parameter, binderFactory, request);
WebDataBinder binder = binderFactory.createBinder(request, target, name);
if (binder.getTarget() != null) {
doBind(binder, webRequest);
if (shouldValidate(binder, parameter)) {
bindRequestParameters(binder, request);
if (isValidationApplicable(binder, parameter)) {
binder.validate();
}
if (failOnError(binder, parameter) && binder.getBindingResult().hasErrors()) {
throw new BindException(binder.getBindingResult());
if (binder.getBindingResult().hasErrors()) {
if (isBindExceptionRequired(binder, parameter)) {
throw new BindException(binder.getBindingResult());
}
}
}
@@ -109,23 +119,22 @@ public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResol
}
/**
* Creates a {@link WebDataBinder} for a target object.
* Creates an instance of the specified model attribute. This method is invoked only if the attribute is
* not available in the model. This default implementation uses the no-argument constructor.
* Subclasses can override to provide additional means of creating the model attribute.
*
* @param attributeName the name of the model attribute
* @param parameter the method argument declaring the model attribute
* @param binderFactory a factory for creating {@link WebDataBinder} instances
* @param request the current request
* @return the created model attribute; never {@code null}
* @throws Exception raised in the process of creating the instance
*/
private WebDataBinder createDataBinder(MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest,
WebDataBinderFactory binderFactory) throws Exception {
String attrName = ModelFactory.getNameForParameter(parameter);
Object target;
if (mavContainer.containsAttribute(attrName)) {
target = mavContainer.getAttribute(attrName);
}
else {
target = BeanUtils.instantiateClass(parameter.getParameterType());
}
return binderFactory.createBinder(webRequest, target, attrName);
protected Object createAttribute(String attributeName,
MethodParameter parameter,
WebDataBinderFactory binderFactory,
NativeWebRequest request) throws Exception {
return BeanUtils.instantiateClass(parameter.getParameterType());
}
/**
@@ -134,17 +143,17 @@ public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResol
* @param binder the binder with the target object to apply request values to
* @param request the current request
*/
protected void doBind(WebDataBinder binder, NativeWebRequest request) {
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
((WebRequestDataBinder) binder).bind(request);
}
/**
* Whether to validate the target object of the given {@link WebDataBinder} instance.
* Whether to validate the model attribute inside the given data binder instance.
* @param binder the data binder containing the validation candidate
* @param parameter the method argument for which data binding is performed
* @return true if {@link DataBinder#validate()} should be invoked, false otherwise.
* @param parameter the method argument declaring the validation candidate
* @return {@code true} if validation should be applied, {@code false} otherwise.
*/
protected boolean shouldValidate(WebDataBinder binder, MethodParameter parameter) {
protected boolean isValidationApplicable(WebDataBinder binder, MethodParameter parameter) {
Annotation[] annotations = parameter.getParameterAnnotations();
for (Annotation annot : annotations) {
if ("Valid".equals(annot.annotationType().getSimpleName())) {
@@ -160,7 +169,7 @@ public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResol
* @param parameter the method argument for which data binding is performed
* @return true if the binding or validation errors should result in a {@link BindException}, false otherwise.
*/
protected boolean failOnError(WebDataBinder binder, MethodParameter parameter) {
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]));

82
org.springframework.web/src/test/java/org/springframework/web/method/annotation/support/ModelAttributeMethodProcessorTests.java
View File

@@ -83,7 +83,7 @@ public class ModelAttributeMethodProcessorTests {
@Before
public void setUp() throws Exception {
processor = new ModelAttributeMethodProcessor(true);
processor = new ModelAttributeMethodProcessor(false);
Method method = ModelAttributeHandler.class.getDeclaredMethod("modelAttribute",
TestBean.class, Errors.class, int.class, TestBean.class, TestBean.class);
@@ -103,68 +103,86 @@ public class ModelAttributeMethodProcessorTests {
}
@Test
public void supportParameter() throws Exception {
processor = new ModelAttributeMethodProcessor(true);
public void supportedParameters() throws Exception {
// Only @ModelAttribute arguments
assertTrue(processor.supportsParameter(paramNamedValidModelAttr));
assertTrue(processor.supportsParameter(paramErrors));
assertFalse(processor.supportsParameter(paramInt));
assertTrue(processor.supportsParameter(paramModelAttr));
assertTrue(processor.supportsParameter(paramNonSimpleType));
processor = new ModelAttributeMethodProcessor(false);
assertTrue(processor.supportsParameter(paramNamedValidModelAttr));
assertFalse(processor.supportsParameter(paramErrors));
assertFalse(processor.supportsParameter(paramInt));
assertTrue(processor.supportsParameter(paramModelAttr));
assertFalse(processor.supportsParameter(paramNonSimpleType));
}
@Test
public void supportsReturnType() throws Exception {
public void supportedParametersInDefaultResolutionMode() throws Exception {
processor = new ModelAttributeMethodProcessor(true);
assertTrue(processor.supportsReturnType(returnParamNamedModelAttr));
assertFalse(processor.supportsReturnType(returnParamNonSimpleType));
// Only non-simple types, even if not annotated
assertTrue(processor.supportsParameter(paramNamedValidModelAttr));
assertTrue(processor.supportsParameter(paramErrors));
assertTrue(processor.supportsParameter(paramModelAttr));
assertTrue(processor.supportsParameter(paramNonSimpleType));
assertFalse(processor.supportsParameter(paramInt));
}
@Test
public void supportedReturnTypes() throws Exception {
processor = new ModelAttributeMethodProcessor(false);
assertTrue(processor.supportsReturnType(returnParamNamedModelAttr));
assertFalse(processor.supportsReturnType(returnParamNonSimpleType));
}
@Test
public void shouldValidate() throws Exception {
assertTrue(processor.shouldValidate(null, paramNamedValidModelAttr));
assertFalse(processor.shouldValidate(null, paramNonSimpleType));
public void supportedReturnTypesInDefaultResolutionMode() throws Exception {
processor = new ModelAttributeMethodProcessor(true);
assertTrue(processor.supportsReturnType(returnParamNamedModelAttr));
assertFalse(processor.supportsReturnType(returnParamNonSimpleType));
}
@Test
public void validationApplicable() throws Exception {
assertTrue(processor.isValidationApplicable(null, paramNamedValidModelAttr));
}
@Test
public void validationNotApplicable() throws Exception {
assertFalse(processor.isValidationApplicable(null, paramNonSimpleType));
}
@Test
public void failOnError() throws Exception {
assertFalse("Shouldn't failOnError with BindingResult", processor.failOnError(null, paramNamedValidModelAttr));
assertTrue("Should failOnError without BindingResult", processor.failOnError(null, paramNonSimpleType));
public void bindExceptionRequired() throws Exception {
assertTrue(processor.isBindExceptionRequired(null, paramNonSimpleType));
}
@Test
public void createBinderFromModelAttribute() throws Exception {
createBinderFromModelAttr("attrName", paramNamedValidModelAttr);
createBinderFromModelAttr("testBean", paramModelAttr);
createBinderFromModelAttr("testBean", paramNonSimpleType);
public void bindExceptionNotRequired() throws Exception {
assertFalse(processor.isBindExceptionRequired(null, paramNamedValidModelAttr));
}
private void createBinderFromModelAttr(String expectedAttrName, MethodParameter param) throws Exception {
@Test
public void getAttributeFromModel() throws Exception {
testGetAttributeFromModel("attrName", paramNamedValidModelAttr);
testGetAttributeFromModel("testBean", paramModelAttr);
testGetAttributeFromModel("testBean", paramNonSimpleType);
}
private void testGetAttributeFromModel(String expectedAttributeName, MethodParameter param) throws Exception {
Object target = new TestBean();
mavContainer.addAttribute(expectedAttrName, target);
mavContainer.addAttribute(expectedAttributeName, target);
WebDataBinder dataBinder = new WebRequestDataBinder(target);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, target, expectedAttrName)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory factory = createMock(WebDataBinderFactory.class);
expect(factory.createBinder(webRequest, target, expectedAttributeName)).andReturn(dataBinder);
replay(factory);
processor.resolveArgument(param, mavContainer, webRequest, binderFactory);
processor.resolveArgument(param, mavContainer, webRequest, factory);
verify(binderFactory);
verify(factory);
}
@Test
public void createBinderWithAttributeConstructor() throws Exception {
public void createAttribute() throws Exception {
WebDataBinder dataBinder = new WebRequestDataBinder(null);
WebDataBinderFactory factory = createMock(WebDataBinderFactory.class);
@@ -177,7 +195,7 @@ public class ModelAttributeMethodProcessorTests {
}
@Test
public void bindAndValidate() throws Exception {
public void automaticValidation() throws Exception {
Object target = new TestBean();
mavContainer.addAttribute("attrName", target);
@@ -193,7 +211,7 @@ public class ModelAttributeMethodProcessorTests {
}
@Test(expected=BindException.class)
public void bindAndFail() throws Exception {
public void bindException() throws Exception {
Object target = new TestBean();
mavContainer.getModel().addAttribute(target);