org.springframework.web.method.annotation

## Class ModelAttributeMethodProcessor

- java.lang.Object
- - org.springframework.web.method.annotation.ModelAttributeMethodProcessor

- All Implemented Interfaces:
    HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler
  Direct Known Subclasses:
    ServletModelAttributeMethodProcessor

      public class ModelAttributeMethodProcessor
      extends Object
      implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler

  Resolves method arguments annotated with `@ModelAttribute` and handles return values from methods annotated with `@ModelAttribute`.

  Model attributes are obtained from the model or if not found possibly created with a default constructor if it is available. Once created, the attributed is populated with request data via data binding and also validation may be applied if the argument is annotated with `@javax.validation.Valid`.

  When this handler is created with `annotationNotRequired=true`, any non-simple type argument and return value is regarded as a model attribute with or without the presence of an `@ModelAttribute`.

  Since:
    3.1
  Author:
    Rossen Stoyanchev

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ModelAttributeMethodProcessor(boolean annotationNotRequired)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `bindRequestParameters(WebDataBinder binder, NativeWebRequest request)` Extension point to bind the request to the target object.
    `protected Object` | `createAttribute(String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory, NativeWebRequest request)` Extension point to create the model attribute if not found in the model.
    `void` | `handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)` Add non-null return values to the `ModelAndViewContainer`.
    `protected boolean` | `isBindExceptionRequired(WebDataBinder binder, MethodParameter parameter)` Whether to raise a `BindException` on validation errors.
    `Object` | `resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest request, WebDataBinderFactory binderFactory)` Resolve the argument from the model or if not found instantiate it with its default if it is available.
    `boolean` | `supportsParameter(MethodParameter parameter)` Whether the given method parameter is supported by this resolver.
    `boolean` | `supportsReturnType(MethodParameter returnType)` Return `true` if there is a method-level `@ModelAttribute` or if it is a non-simple type when `annotationNotRequired=true`.
    `protected void` | `validateIfApplicable(WebDataBinder binder, MethodParameter parameter)` Validate the model attribute if applicable.

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

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

- - ### Field Detail

    - #### logger

          protected Log logger

  - ### Constructor Detail

    - #### ModelAttributeMethodProcessor

          public ModelAttributeMethodProcessor(boolean annotationNotRequired)

      Parameters:
        `annotationNotRequired` - if "true", non-simple method arguments and return values are considered model attributes with or without a `@ModelAttribute` annotation.

  - ### Method Detail

    - #### supportsParameter

          public boolean supportsParameter(MethodParameter parameter)

      Description copied from interface: `HandlerMethodArgumentResolver`
      Whether the given method parameter is supported by this resolver.
      Specified by:
        `supportsParameter` in interface `HandlerMethodArgumentResolver`
      Parameters:
        `parameter` - the method parameter to check
      Returns:
        true if the parameter is annotated with `ModelAttribute` or in default resolution mode also if it is not a simple type.

    - #### resolveArgument

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

      Resolve the argument from the model or if not found instantiate it with its default if it is available. The model attribute is then populated with request values via data binding and optionally validated if `@java.validation.Valid` is present on the argument.
      Specified by:
        `resolveArgument` in interface `HandlerMethodArgumentResolver`
      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
        `request` - the current request
        `binderFactory` - a factory for creating `WebDataBinder` instances
      Returns:
        the resolved argument value, or `null`.
      Throws:
        `BindException` - if data binding and validation result in an error and the next method parameter is not of type `Errors`.
        `Exception` - if WebDataBinder initialization fails.

    - #### createAttribute

          protected Object createAttribute(String attributeName,
                               MethodParameter parameter,
                               WebDataBinderFactory binderFactory,
                               NativeWebRequest request)
                                    throws Exception

      Extension point to create the model attribute if not found in the model. The default implementation uses the default constructor.
      Parameters:
        `attributeName` - the name of the attribute, never `null`
        `parameter` - the method parameter
        `binderFactory` - for creating WebDataBinder instance
        `request` - the current request
      Returns:
        the created model attribute, never `null`
      Throws:
        `Exception`

    - #### bindRequestParameters

          protected void bindRequestParameters(WebDataBinder binder,
                                   NativeWebRequest request)

      Extension point to bind the request to the target object.
      Parameters:
        `binder` - the data binder instance to use for the binding
        `request` - the current request

    - #### validateIfApplicable

          protected void validateIfApplicable(WebDataBinder binder,
                                  MethodParameter parameter)

      Validate the model attribute if applicable.

      The default implementation checks for `@javax.validation.Valid`.

      Parameters:
        `binder` - the DataBinder to be used
        `parameter` - the method parameter

    - #### isBindExceptionRequired

          protected boolean isBindExceptionRequired(WebDataBinder binder,
                                        MethodParameter parameter)

      Whether to raise a `BindException` on validation errors.
      Parameters:
        `binder` - the data binder used to perform data binding
        `parameter` - the method argument
      Returns:
        `true` if the next method argument is not of type `Errors`.

    - #### supportsReturnType

          public boolean supportsReturnType(MethodParameter returnType)

      Return `true` if there is a method-level `@ModelAttribute` or if it is a non-simple type when `annotationNotRequired=true`.
      Specified by:
        `supportsReturnType` in interface `HandlerMethodReturnValueHandler`
      Parameters:
        `returnType` - the method return type to check
      Returns:
        `true` if this handler supports the supplied return type; `false` otherwise

    - #### handleReturnValue

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

      Add non-null return values to the `ModelAndViewContainer`.
      Specified by:
        `handleReturnValue` in interface `HandlerMethodReturnValueHandler`
      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:
        `Exception` - if the return value handling results in an error