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
    Modifier and Type | Method and Description
    --- | ---
    `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`