GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

@RequestBody supports java.util.Optional 

Issue: SPR-15007
pull/1267/head
Juergen Hoeller 9 years ago
parent
52f664139f
commit
eeb7ae537f
4 changed files with 122 additions and 70 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 69
      spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMessageConverterMethodArgumentResolver.java
  2. 14
      spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestPartMethodArgumentResolver.java
  3. 19
      spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessor.java
  4. 90
      spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java

69
spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMessageConverterMethodArgumentResolver.java
Unescape View File

@ -22,10 +22,12 @@ import java.io.PushbackInputStream;
import java.lang.annotation.Annotation; import java.lang.annotation.Annotation;
import java.lang.reflect.Type; import java.lang.reflect.Type;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.EnumSet; import java.util.EnumSet;
import java.util.LinkedHashSet; import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
@ -59,6 +61,7 @@ import org.springframework.web.method.support.HandlerMethodArgumentResolver;
* *
* @author Arjen Poutsma * @author Arjen Poutsma
* @author Rossen Stoyanchev * @author Rossen Stoyanchev
* @author Juergen Hoeller
* @since 3.1 * @since 3.1
*/ */
public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver { public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {
@ -128,17 +131,17 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
* reading from the given request. * reading from the given request.
* @param <T> the expected type of the argument value to be created * @param <T> the expected type of the argument value to be created
* @param webRequest the current request * @param webRequest the current request
* @param methodParam the method argument * @param parameter the method parameter descriptor (may be {@code null})
* @param paramType the type of the argument value to be created * @param paramType the type of the argument value to be created
* @return the created method argument value * @return the created method argument value
* @throws IOException if the reading from the request fails * @throws IOException if the reading from the request fails
* @throws HttpMediaTypeNotSupportedException if no suitable message converter is found * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
*/ */
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam, protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
HttpInputMessage inputMessage = createInputMessage(webRequest); HttpInputMessage inputMessage = createInputMessage(webRequest);
return readWithMessageConverters(inputMessage, methodParam, paramType); return readWithMessageConverters(inputMessage, parameter, paramType);
} }
/** /**
@ -146,7 +149,7 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
* from the given HttpInputMessage. * from the given HttpInputMessage.
* @param <T> the expected type of the argument value to be created * @param <T> the expected type of the argument value to be created
* @param inputMessage the HTTP input message representing the current request * @param inputMessage the HTTP input message representing the current request
* @param param the method parameter descriptor (may be {@code null}) * @param parameter the method parameter descriptor (may be {@code null})
* @param targetType the target type, not necessarily the same as the method * @param targetType the target type, not necessarily the same as the method
* parameter type, e.g. for {@code HttpEntity<String>}. * parameter type, e.g. for {@code HttpEntity<String>}.
* @return the created method argument value * @return the created method argument value
@ -154,7 +157,7 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
* @throws HttpMediaTypeNotSupportedException if no suitable message converter is found * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter param, protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
MediaType contentType; MediaType contentType;
@ -170,11 +173,11 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
contentType = MediaType.APPLICATION_OCTET_STREAM; contentType = MediaType.APPLICATION_OCTET_STREAM;
} }
Class<?> contextClass = (param != null ? param.getContainingClass() : null); Class<?> contextClass = (parameter != null ? parameter.getContainingClass() : null);
Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null); Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
if (targetClass == null) { if (targetClass == null) {
ResolvableType resolvableType = (param != null ? ResolvableType resolvableType = (parameter != null ?
ResolvableType.forMethodParameter(param) : ResolvableType.forType(targetType)); ResolvableType.forMethodParameter(parameter) : ResolvableType.forType(targetType));
targetClass = (Class<T>) resolvableType.resolve(); targetClass = (Class<T>) resolvableType.resolve();
} }
@ -193,13 +196,12 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]"); logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
} }
if (inputMessage.getBody() != null) { if (inputMessage.getBody() != null) {
inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType); inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
body = genericConverter.read(targetType, contextClass, inputMessage); body = genericConverter.read(targetType, contextClass, inputMessage);
body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType); body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
} }
else { else {
body = null; body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType);
} }
break; break;
} }
@ -210,13 +212,12 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]"); logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
} }
if (inputMessage.getBody() != null) { if (inputMessage.getBody() != null) {
inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType); inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage); body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType); body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
} }
else { else {
body = null; body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType);
} }
break; break;
} }
@ -254,12 +255,12 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
* Spring's {@link org.springframework.validation.annotation.Validated}, * Spring's {@link org.springframework.validation.annotation.Validated},
* and custom annotations whose name starts with "Valid". * and custom annotations whose name starts with "Valid".
* @param binder the DataBinder to be used * @param binder the DataBinder to be used
* @param methodParam the method parameter * @param parameter the method parameter descriptor
* @see #isBindExceptionRequired
* @since 4.1.5 * @since 4.1.5
* @see #isBindExceptionRequired
*/ */
protected void validateIfApplicable(WebDataBinder binder, MethodParameter methodParam) { protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
Annotation[] annotations = methodParam.getParameterAnnotations(); Annotation[] annotations = parameter.getParameterAnnotations();
for (Annotation ann : annotations) { for (Annotation ann : annotations) {
Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class); Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) { if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
@ -274,17 +275,37 @@ public abstract class AbstractMessageConverterMethodArgumentResolver implements
/** /**
* Whether to raise a fatal bind exception on validation errors. * Whether to raise a fatal bind exception on validation errors.
* @param binder the data binder used to perform data binding * @param binder the data binder used to perform data binding
* @param methodParam the method argument * @param parameter the method parameter descriptor
* @return {@code true} if the next method argument is not of type {@link Errors} * @return {@code true} if the next method argument is not of type {@link Errors}
* @since 4.1.5 * @since 4.1.5
*/ */
protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter methodParam) { protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter parameter) {
int i = methodParam.getParameterIndex(); int i = parameter.getParameterIndex();
Class<?>[] paramTypes = methodParam.getMethod().getParameterTypes(); Class<?>[] paramTypes = parameter.getMethod().getParameterTypes();
boolean hasBindingResult = (paramTypes.length > (i + 1) && Errors.class.isAssignableFrom(paramTypes[i + 1])); boolean hasBindingResult = (paramTypes.length > (i + 1) && Errors.class.isAssignableFrom(paramTypes[i + 1]));
return !hasBindingResult; return !hasBindingResult;
} }
/**
* Adapt the given argument against the method parameter, if necessary.
* @param arg the resolved argument
* @param parameter the method parameter descriptor
* @return the adapted argument, or the original resolved argument as-is
* @since 4.3.5
*/
protected Object adaptArgumentIfNecessary(Object arg, MethodParameter parameter) {
if (parameter.getParameterType() == Optional.class) {
if (arg == null || (arg instanceof Collection && ((Collection) arg).isEmpty()) ||
(arg instanceof Object[] && ((Object[]) arg).length == 0)) {
return Optional.empty();
}
else {
return Optional.of(arg);
}
}
return arg;
}
private static class EmptyBodyCheckingHttpInputMessage implements HttpInputMessage { private static class EmptyBodyCheckingHttpInputMessage implements HttpInputMessage {

14
spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestPartMethodArgumentResolver.java
Unescape View File

@ -16,9 +16,7 @@
package org.springframework.web.servlet.mvc.method.annotation; package org.springframework.web.servlet.mvc.method.annotation;
import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Optional;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
@ -156,17 +154,7 @@ public class RequestPartMethodArgumentResolver extends AbstractMessageConverterM
throw new MissingServletRequestPartException(name); throw new MissingServletRequestPartException(name);
} }
} }
if (parameter.getParameterType() == Optional.class) { return adaptArgumentIfNecessary(arg, parameter);
if (arg == null || (arg instanceof Collection && ((Collection) arg).isEmpty()) ||
(arg instanceof Object[] && ((Object[]) arg).length == 0)) {
arg = Optional.empty();
}
else {
arg = Optional.of(arg);
}
}
return arg;
} }
private String getPartName(MethodParameter methodParam, RequestPart requestPart) { private String getPartName(MethodParameter methodParam, RequestPart requestPart) {

19
spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessor.java
Unescape View File

@ -19,7 +19,6 @@ package org.springframework.web.servlet.mvc.method.annotation;
import java.io.IOException; import java.io.IOException;
import java.lang.reflect.Type; import java.lang.reflect.Type;
import java.util.List; import java.util.List;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import org.springframework.core.Conventions; import org.springframework.core.Conventions;
@ -55,6 +54,7 @@ import org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolv
* *
* @author Arjen Poutsma * @author Arjen Poutsma
* @author Rossen Stoyanchev * @author Rossen Stoyanchev
* @author Juergen Hoeller
* @since 3.1 * @since 3.1
*/ */
public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor { public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
@ -124,7 +124,8 @@ public class RequestResponseBodyMethodProcessor extends AbstractMessageConverter
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType()); parameter = parameter.nestedIfOptional();
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
String name = Conventions.getVariableNameForParameter(parameter); String name = Conventions.getVariableNameForParameter(parameter);
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name); WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
@ -136,28 +137,28 @@ public class RequestResponseBodyMethodProcessor extends AbstractMessageConverter
} }
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult()); mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
return arg; return adaptArgumentIfNecessary(arg, parameter);
} }
@Override @Override
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam, protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class); HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest); ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
Object arg = readWithMessageConverters(inputMessage, methodParam, paramType); Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
if (arg == null) { if (arg == null) {
if (checkRequired(methodParam)) { if (checkRequired(parameter)) {
throw new HttpMessageNotReadableException("Required request body is missing: " + throw new HttpMessageNotReadableException("Required request body is missing: " +
methodParam.getMethod().toGenericString()); parameter.getMethod().toGenericString());
} }
} }
return arg; return arg;
} }
protected boolean checkRequired(MethodParameter methodParam) { protected boolean checkRequired(MethodParameter parameter) {
return methodParam.getParameterAnnotation(RequestBody.class).required(); return (parameter.getParameterAnnotation(RequestBody.class).required() && !parameter.isOptional());
} }
@Override @Override

90
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java
Unescape View File

@ -21,6 +21,7 @@ import java.nio.charset.StandardCharsets;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Optional;
import javax.validation.Valid; import javax.validation.Valid;
import javax.validation.constraints.NotNull; import javax.validation.constraints.NotNull;
@ -61,6 +62,7 @@ import static org.mockito.BDDMockito.*;
* *
* @author Arjen Poutsma * @author Arjen Poutsma
* @author Rossen Stoyanchev * @author Rossen Stoyanchev
* @author Juergen Hoeller
*/ */
public class RequestResponseBodyMethodProcessorMockTests { public class RequestResponseBodyMethodProcessorMockTests {
@ -74,6 +76,7 @@ public class RequestResponseBodyMethodProcessorMockTests {
private MethodParameter paramInt; private MethodParameter paramInt;
private MethodParameter paramValidBean; private MethodParameter paramValidBean;
private MethodParameter paramStringNotRequired; private MethodParameter paramStringNotRequired;
private MethodParameter paramOptionalString;
private MethodParameter returnTypeString; private MethodParameter returnTypeString;
private MethodParameter returnTypeInt; private MethodParameter returnTypeInt;
private MethodParameter returnTypeStringProduces; private MethodParameter returnTypeStringProduces;
@ -102,12 +105,13 @@ public class RequestResponseBodyMethodProcessorMockTests {
Method methodHandle1 = getClass().getMethod("handle1", String.class, Integer.TYPE); Method methodHandle1 = getClass().getMethod("handle1", String.class, Integer.TYPE);
paramRequestBodyString = new MethodParameter(methodHandle1, 0); paramRequestBodyString = new MethodParameter(methodHandle1, 0);
paramInt = new MethodParameter(methodHandle1, 1); paramInt = new MethodParameter(methodHandle1, 1);
paramValidBean = new MethodParameter(getClass().getMethod("handle2", SimpleBean.class), 0);
paramStringNotRequired = new MethodParameter(getClass().getMethod("handle3", String.class), 0);
paramOptionalString = new MethodParameter(getClass().getMethod("handle4", Optional.class), 0);
returnTypeString = new MethodParameter(methodHandle1, -1); returnTypeString = new MethodParameter(methodHandle1, -1);
returnTypeInt = new MethodParameter(getClass().getMethod("handle2"), -1); returnTypeInt = new MethodParameter(getClass().getMethod("handle5"), -1);
returnTypeStringProduces = new MethodParameter(getClass().getMethod("handle3"), -1); returnTypeStringProduces = new MethodParameter(getClass().getMethod("handle6"), -1);
returnTypeResource = new MethodParameter(getClass().getMethod("handle6"), -1); returnTypeResource = new MethodParameter(getClass().getMethod("handle7"), -1);
paramValidBean = new MethodParameter(getClass().getMethod("handle4", SimpleBean.class), 0);
paramStringNotRequired = new MethodParameter(getClass().getMethod("handle5", String.class), 0);
mavContainer = new ModelAndViewContainer(); mavContainer = new ModelAndViewContainer();
@ -204,9 +208,7 @@ public class RequestResponseBodyMethodProcessorMockTests {
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null); processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
} }
// SPR-9942 @Test(expected = HttpMessageNotReadableException.class) // SPR-9942
@Test(expected = HttpMessageNotReadableException.class)
public void resolveArgumentRequiredNoContent() throws Exception { public void resolveArgumentRequiredNoContent() throws Exception {
servletRequest.setContentType(MediaType.TEXT_PLAIN_VALUE); servletRequest.setContentType(MediaType.TEXT_PLAIN_VALUE);
servletRequest.setContent(new byte[0]); servletRequest.setContent(new byte[0]);
@ -215,6 +217,23 @@ public class RequestResponseBodyMethodProcessorMockTests {
assertNull(processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory())); assertNull(processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory()));
} }
@Test
public void resolveArgumentNotGetRequests() throws Exception {
servletRequest.setMethod("GET");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.class, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
assertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotRequiredWithContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.class), isA(HttpInputMessage.class))).willReturn("body");
assertEquals("body", processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test @Test
public void resolveArgumentNotRequiredNoContent() throws Exception { public void resolveArgumentNotRequiredNoContent() throws Exception {
servletRequest.setContentType("text/plain"); servletRequest.setContentType("text/plain");
@ -223,8 +242,7 @@ public class RequestResponseBodyMethodProcessorMockTests {
assertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())); assertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
} }
// SPR-13417 @Test // SPR-13417
@Test
public void resolveArgumentNotRequiredNoContentNoContentType() throws Exception { public void resolveArgumentNotRequiredNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]); servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true); given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true);
@ -233,11 +251,28 @@ public class RequestResponseBodyMethodProcessorMockTests {
} }
@Test @Test
public void resolveArgumentNotGetRequests() throws Exception { public void resolveArgumentOptionalWithContent() throws Exception {
servletRequest.setMethod("GET"); servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.class), isA(HttpInputMessage.class))).willReturn("body");
assertEquals(Optional.of("body"), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentOptionalNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]); servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true);
assertEquals(Optional.empty(), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentOptionalNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.class, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.canRead(String.class, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false); given(stringMessageConverter.canRead(String.class, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
assertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())); assertEquals(Optional.empty(), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
} }
@Test @Test
@ -311,9 +346,7 @@ public class RequestResponseBodyMethodProcessorMockTests {
assertEquals(200, servletResponse.getStatus()); assertEquals(200, servletResponse.getStatus());
} }
// SPR-9841 @Test // SPR-9841
@Test
public void handleReturnValueMediaTypeSuffix() throws Exception { public void handleReturnValueMediaTypeSuffix() throws Exception {
String body = "Foo"; String body = "Foo";
MediaType accepted = MediaType.APPLICATION_XHTML_XML; MediaType accepted = MediaType.APPLICATION_XHTML_XML;
@ -339,29 +372,37 @@ public class RequestResponseBodyMethodProcessorMockTests {
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
public int handle2() { public void handle2(@Valid @RequestBody SimpleBean b) {
return 42;
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
@ResponseBody public void handle3(@RequestBody(required = false) String s) {
public String handle3() {
return null;
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
public void handle4(@Valid @RequestBody SimpleBean b) { public void handle4(@RequestBody Optional<String> s) {
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
public void handle5(@RequestBody(required=false) String s) { public int handle5() {
return 42;
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
@ResponseBody @ResponseBody
public Resource handle6() {return null;} public String handle6() {
return null;
}
@SuppressWarnings("unused")
@ResponseBody
public Resource handle7() {
return null;
}
private final class ValidatingBinderFactory implements WebDataBinderFactory { private final class ValidatingBinderFactory implements WebDataBinderFactory {
@Override @Override
public WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName) throws Exception { public WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean(); LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
@ -372,6 +413,7 @@ public class RequestResponseBodyMethodProcessorMockTests {
} }
} }
@SuppressWarnings("unused") @SuppressWarnings("unused")
private static class SimpleBean { private static class SimpleBean {

Write Preview
Loading…
Cancel
Save