org.springframework.web.servlet.mvc.method.annotation

## Class RequestResponseBodyMethodProcessor

- java.lang.Object
- - org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver
  - - org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor
    - - org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor

All Implemented Interfaces:
  HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler

    public class RequestResponseBodyMethodProcessor
    extends AbstractMessageConverterMethodProcessor

Resolves method arguments annotated with `@RequestBody` and handles return values from methods annotated with `@ResponseBody` by reading and writing to the body of the request or response with an `HttpMessageConverter`.

An `@RequestBody` method argument is also validated if it is annotated with `@javax.validation.Valid`. In case of validation failure, `MethodArgumentNotValidException` is raised and results in a 400 response status code if `DefaultHandlerExceptionResolver` is configured.

Since:
  3.1
Author:
  Arjen Poutsma, Rossen Stoyanchev

### Field Summary

### Fields inherited from class org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver

`allSupportedMediaTypes, logger, messageConverters`

### Constructor Summary

Constructors
Constructor and Description
`RequestResponseBodyMethodProcessor(List<HttpMessageConverter<?>> messageConverters)`
`RequestResponseBodyMethodProcessor(List<HttpMessageConverter<?>> messageConverters, ContentNegotiationManager contentNegotiationManager)`

### Method Summary

Methods
`void` `handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)` Handle the given return value by adding attributes to the model and setting a view or setting the `ModelAndViewContainer.setRequestHandled(boolean)` flag to `true` to indicate the response has been handled directly.
`protected <T> Object` `readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam, Type paramType)` Creates the method argument value of the expected parameter type by reading from the given request.
`Object` `resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory)` Resolves a method parameter into an argument value from a given request.
`boolean` `supportsParameter(MethodParameter parameter)` Whether the given method parameter is supported by this resolver.
`boolean` `supportsReturnType(MethodParameter returnType)` Whether the given method return type is supported by this handler.

### Methods inherited from class org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor

`createOutputMessage, getProducibleMediaTypes, writeWithMessageConverters, writeWithMessageConverters`

### Methods inherited from class org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver

`createInputMessage, readWithMessageConverters`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### RequestResponseBodyMethodProcessor

    public RequestResponseBodyMethodProcessor(List<HttpMessageConverter<?>> messageConverters)

#### RequestResponseBodyMethodProcessor

    public RequestResponseBodyMethodProcessor(List<HttpMessageConverter<?>> messageConverters,
                                      ContentNegotiationManager contentNegotiationManager)

### Method Detail

#### supportsParameter

    public boolean supportsParameter(MethodParameter parameter)

Description copied from interface: `HandlerMethodArgumentResolver`
Whether the given method parameter is supported by this resolver.

Parameters:
  `parameter` - the method parameter to check
Returns:
  `true` if this resolver supports the supplied parameter; `false` otherwise

#### supportsReturnType

    public boolean supportsReturnType(MethodParameter returnType)

Description copied from interface: `HandlerMethodReturnValueHandler`
Whether the given method return type is supported by this handler.

Parameters:
  `returnType` - the method return type to check
Returns:
  `true` if this handler supports the supplied return type; `false` otherwise

#### resolveArgument

    public Object resolveArgument(MethodParameter parameter,
                         ModelAndViewContainer mavContainer,
                         NativeWebRequest webRequest,
                         WebDataBinderFactory binderFactory)
                           throws Exception

Resolves a method parameter into an argument value from a given request. A `ModelAndViewContainer` provides access to the model for the request. A `WebDataBinderFactory` provides a way to create a `WebDataBinder` instance when needed for data binding and type conversion purposes.

Parameters:
  `parameter` - the method parameter to resolve. This parameter must have previously been passed to `HandlerMethodArgumentResolver.supportsParameter(org.springframework.core.MethodParameter)` and it must have returned `true`
  `mavContainer` - the ModelAndViewContainer for the current request
  `webRequest` - the current request
  `binderFactory` - a factory for creating `WebDataBinder` instances
Returns:
  the resolved argument value, or `null`.
Throws:
  `MethodArgumentNotValidException` - if validation fails
  `HttpMessageNotReadableException` - if `RequestBody.required()` is `true` and there is no body content or if there is no suitable converter to read the content with.
  `Exception` - in case of errors with the preparation of argument values

#### readWithMessageConverters

    protected <T> Object readWithMessageConverters(NativeWebRequest webRequest,
                                       MethodParameter methodParam,
                                       Type paramType)
                                        throws IOException,
                                               HttpMediaTypeNotSupportedException

Description copied from class: `AbstractMessageConverterMethodArgumentResolver`
Creates the method argument value of the expected parameter type by reading from the given request.

Overrides:
  `readWithMessageConverters` in class `AbstractMessageConverterMethodArgumentResolver`
Type Parameters:
  `T` - the expected type of the argument value to be created
Parameters:
  `webRequest` - the current request
  `methodParam` - the method argument
  `paramType` - the type of the argument value to be created
Returns:
  the created method argument value
Throws:
  `IOException` - if the reading from the request fails
  `HttpMediaTypeNotSupportedException` - if no suitable message converter is found

#### handleReturnValue

    public void handleReturnValue(Object returnValue,
                         MethodParameter returnType,
                         ModelAndViewContainer mavContainer,
                         NativeWebRequest webRequest)
                           throws IOException,
                                  HttpMediaTypeNotAcceptableException

Description copied from interface: `HandlerMethodReturnValueHandler`
Handle the given return value by adding attributes to the model and setting a view or setting the `ModelAndViewContainer.setRequestHandled(boolean)` flag to `true` to indicate the response has been handled directly.

Parameters:
  `returnValue` - the value returned from the handler method
  `returnType` - the type of the return value. This type must have previously been passed to `HandlerMethodReturnValueHandler.supportsReturnType(org.springframework.core.MethodParameter)` and it must have returned `true`
  `mavContainer` - the ModelAndViewContainer for the current request
  `webRequest` - the current request
Throws:
  `IOException`
  `HttpMediaTypeNotAcceptableException`