Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.web.servlet.mvc.method.annotation
Class RequestMappingHandlerAdapter

    java.lang.Object
      org.springframework.context.support.ApplicationObjectSupport
          org.springframework.web.context.support.WebApplicationObjectSupport
              org.springframework.web.servlet.support.WebContentGenerator
                  org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter
                      org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

All Implemented Interfaces:
  Aware, BeanFactoryAware, InitializingBean, ApplicationContextAware, Ordered, ServletContextAware, HandlerAdapter

    public class RequestMappingHandlerAdapter

extends AbstractHandlerMethodAdapter
implements BeanFactoryAware, InitializingBean

An `AbstractHandlerMethodAdapter` that supports `HandlerMethod`s with the signature -- method argument and return types, defined in `@RequestMapping`.

Support for custom argument and return value types can be added via `setCustomArgumentResolvers(java.util.List)` and `setCustomReturnValueHandlers(java.util.List)`. Or alternatively to re-configure all argument and return value types use `setArgumentResolvers(java.util.List)` and `setReturnValueHandlers(List)`.

Since:
  3.1
Author:
  Rossen Stoyanchev
See Also:
  `HandlerMethodArgumentResolver`, `HandlerMethodReturnValueHandler`

Field Summary
`static ReflectionUtils.MethodFilter` | `INIT_BINDER_METHODS` MethodFilter that matches `@InitBinder` methods.
`static ReflectionUtils.MethodFilter` | `MODEL_ATTRIBUTE_METHODS` MethodFilter that matches `@ModelAttribute` methods.

Fields inherited from class org.springframework.web.servlet.support.WebContentGenerator
`METHOD_GET, METHOD_HEAD, METHOD_POST`

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport
`logger`

Fields inherited from interface org.springframework.core.Ordered
`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

Constructor Summary
`RequestMappingHandlerAdapter()` Default constructor.

Method Summary
`void` | `afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`protected ServletRequestDataBinderFactory` | `createDataBinderFactory(java.util.List<InvocableHandlerMethod> binderMethods)` Template method to create a new ServletRequestDataBinderFactory instance.
`HandlerMethodArgumentResolverComposite` | `getArgumentResolvers()` Return the configured argument resolvers, or possibly `null` if not initialized yet via `afterPropertiesSet()`.
`protected ConfigurableBeanFactory` | `getBeanFactory()` Return the owning factory of this bean instance, or `null`.
`java.util.List<HandlerMethodArgumentResolver>` | `getCustomArgumentResolvers()` Return the custom argument resolvers, or `null`.
`java.util.List<HandlerMethodReturnValueHandler>` | `getCustomReturnValueHandlers()` Return the custom return value handlers, or `null`.
`HandlerMethodArgumentResolverComposite` | `getInitBinderArgumentResolvers()` Return the argument resolvers for `@InitBinder` methods, or possibly `null` if not initialized yet via `afterPropertiesSet()`.
`protected long` | `getLastModifiedInternal(javax.servlet.http.HttpServletRequest request, HandlerMethod handlerMethod)` This implementation always returns -1.
`java.util.List<HttpMessageConverter<?>>` | `getMessageConverters()` Return the configured message body converters.
`java.util.List<ModelAndViewResolver>` | `getModelAndViewResolvers()` Return the configured `ModelAndViewResolver`s, or `null`.
`HandlerMethodReturnValueHandlerComposite` | `getReturnValueHandlers()` Return the configured handlers, or possibly `null` if not initialized yet via `afterPropertiesSet()`.
`WebBindingInitializer` | `getWebBindingInitializer()` Return the configured WebBindingInitializer, or `null`.
`protected ModelAndView` | `handleInternal(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response, HandlerMethod handlerMethod)` Use the given handler method to handle the request.
`void` | `setArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)` Configure the complete list of supported argument types thus overriding the resolvers that would otherwise be configured by default.
`void` | `setAsyncRequestTimeout(long asyncRequestTimeout)` Set the timeout for asynchronous request processing in milliseconds.
`void` | `setAsyncTaskExecutor(AsyncTaskExecutor taskExecutor)` Set the AsyncTaskExecutor to use when a controller method returns a `Callable`.
`void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
`void` | `setCacheSecondsForSessionAttributeHandlers(int cacheSecondsForSessionAttributeHandlers)` Cache content produced by `@SessionAttributes` annotated handlers for the given number of seconds.
`void` | `setCustomArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)` Provide resolvers for custom argument types.
`void` | `setCustomReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> returnValueHandlers)` Provide handlers for custom return value types.
`void` | `setIgnoreDefaultModelOnRedirect(boolean ignoreDefaultModelOnRedirect)` By default the content of the "default" model is used both during rendering and redirect scenarios.
`void` | `setInitBinderArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)` Configure the supported argument types in `@InitBinder` methods.
`void` | `setMessageConverters(java.util.List<HttpMessageConverter<?>> messageConverters)` Provide the converters to use in argument resolvers and return value handlers that support reading and/or writing to the body of the request and response.
`void` | `setModelAndViewResolvers(java.util.List<ModelAndViewResolver> modelAndViewResolvers)` Provide custom `ModelAndViewResolver`s.
`void` | `setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer)` Set the ParameterNameDiscoverer to use for resolving method parameter names if needed (e.g.
`void` | `setReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> returnValueHandlers)` Configure the complete list of supported return value types thus overriding handlers that would otherwise be configured by default.
`void` | `setSessionAttributeStore(SessionAttributeStore sessionAttributeStore)` Specify the strategy to store session attributes with.
`void` | `setSynchronizeOnSession(boolean synchronizeOnSession)` Set if controller execution should be synchronized on the session, to serialize parallel invocations from the same client.
`void` | `setWebBindingInitializer(WebBindingInitializer webBindingInitializer)` Provide a WebBindingInitializer with "global" initialization to apply to every DataBinder instance.
`protected boolean` | `supportsInternal(HandlerMethod handlerMethod)` Always return `true` since any method argument and return value type will be processed in some way.

Methods inherited from class org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter
`getLastModified, getOrder, handle, setOrder, supports`

Methods inherited from class org.springframework.web.servlet.support.WebContentGenerator
`applyCacheSeconds, applyCacheSeconds, cacheForSeconds, cacheForSeconds, checkAndPrepare, checkAndPrepare, getCacheSeconds, getSupportedMethods, isRequireSession, isUseCacheControlHeader, isUseCacheControlNoStore, isUseExpiresHeader, preventCaching, setCacheSeconds, setRequireSession, setSupportedMethods, setUseCacheControlHeader, setUseCacheControlNoStore, setUseExpiresHeader`

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport
`getServletContext, getTempDir, getWebApplicationContext, initApplicationContext, initServletContext, isContextRequired, setServletContext`

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport
`getApplicationContext, getMessageSourceAccessor, initApplicationContext, requiredContextClass, setApplicationContext`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### INIT_BINDER_METHODS

    public static final ReflectionUtils.MethodFilter INIT_BINDER_METHODS

  MethodFilter that matches `@InitBinder` methods.

### MODEL_ATTRIBUTE_METHODS

    public static final ReflectionUtils.MethodFilter MODEL_ATTRIBUTE_METHODS

  MethodFilter that matches `@ModelAttribute` methods.

Constructor Detail

### RequestMappingHandlerAdapter

    public RequestMappingHandlerAdapter()

  Default constructor.

Method Detail

### setCustomArgumentResolvers

    public void setCustomArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)

  Provide resolvers for custom argument types. Custom resolvers are ordered after built-in ones. To override the built-in support for argument resolution use `setArgumentResolvers(java.util.List)` instead.

### getCustomArgumentResolvers

    public java.util.List<HandlerMethodArgumentResolver> getCustomArgumentResolvers()

  Return the custom argument resolvers, or `null`.

### setArgumentResolvers

    public void setArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)

  Configure the complete list of supported argument types thus overriding the resolvers that would otherwise be configured by default.

### getArgumentResolvers

    public HandlerMethodArgumentResolverComposite getArgumentResolvers()

  Return the configured argument resolvers, or possibly `null` if not initialized yet via `afterPropertiesSet()`.

### setInitBinderArgumentResolvers

    public void setInitBinderArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)

  Configure the supported argument types in `@InitBinder` methods.

### getInitBinderArgumentResolvers

    public HandlerMethodArgumentResolverComposite getInitBinderArgumentResolvers()

  Return the argument resolvers for `@InitBinder` methods, or possibly `null` if not initialized yet via `afterPropertiesSet()`.

### setCustomReturnValueHandlers

    public void setCustomReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> returnValueHandlers)

  Provide handlers for custom return value types. Custom handlers are ordered after built-in ones. To override the built-in support for return value handling use `setReturnValueHandlers(java.util.List)`.

### getCustomReturnValueHandlers

    public java.util.List<HandlerMethodReturnValueHandler> getCustomReturnValueHandlers()

  Return the custom return value handlers, or `null`.

### setReturnValueHandlers

    public void setReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> returnValueHandlers)

  Configure the complete list of supported return value types thus overriding handlers that would otherwise be configured by default.

### getReturnValueHandlers

    public HandlerMethodReturnValueHandlerComposite getReturnValueHandlers()

  Return the configured handlers, or possibly `null` if not initialized yet via `afterPropertiesSet()`.

### setModelAndViewResolvers

    public void setModelAndViewResolvers(java.util.List<ModelAndViewResolver> modelAndViewResolvers)

  Provide custom `ModelAndViewResolver`s.

  Note: This method is available for backwards compatibility only. However, it is recommended to re-write a `ModelAndViewResolver` as `HandlerMethodReturnValueHandler`. An adapter between the two interfaces is not possible since the `HandlerMethodReturnValueHandler.supportsReturnType(org.springframework.core.MethodParameter)` method cannot be implemented. Hence `ModelAndViewResolver`s are limited to always being invoked at the end after all other return value handlers have been given a chance.

  A `HandlerMethodReturnValueHandler` provides better access to the return type and controller method information and can be ordered freely relative to other return value handlers.

### getModelAndViewResolvers

    public java.util.List<ModelAndViewResolver> getModelAndViewResolvers()

  Return the configured `ModelAndViewResolver`s, or `null`.

### setMessageConverters

    public void setMessageConverters(java.util.List<HttpMessageConverter<?>> messageConverters)

  Provide the converters to use in argument resolvers and return value handlers that support reading and/or writing to the body of the request and response.

### getMessageConverters

    public java.util.List<HttpMessageConverter<?>> getMessageConverters()

  Return the configured message body converters.

### setWebBindingInitializer

    public void setWebBindingInitializer(WebBindingInitializer webBindingInitializer)

  Provide a WebBindingInitializer with "global" initialization to apply to every DataBinder instance.

### getWebBindingInitializer

    public WebBindingInitializer getWebBindingInitializer()

  Return the configured WebBindingInitializer, or `null`.

### setSessionAttributeStore

    public void setSessionAttributeStore(SessionAttributeStore sessionAttributeStore)

  Specify the strategy to store session attributes with. The default is `DefaultSessionAttributeStore`, storing session attributes in the HttpSession with the same attribute name as in the model.

### setCacheSecondsForSessionAttributeHandlers

    public void setCacheSecondsForSessionAttributeHandlers(int cacheSecondsForSessionAttributeHandlers)

  Cache content produced by `@SessionAttributes` annotated handlers for the given number of seconds. Default is 0, preventing caching completely.

  In contrast to the "cacheSeconds" property which will apply to all general handlers (but not to `@SessionAttributes` annotated handlers), this setting will apply to `@SessionAttributes` handlers only.

  See Also:
    `WebContentGenerator.setCacheSeconds(int)`, `SessionAttributes`

### setSynchronizeOnSession

    public void setSynchronizeOnSession(boolean synchronizeOnSession)

  Set if controller execution should be synchronized on the session, to serialize parallel invocations from the same client.

  More specifically, the execution of the `handleRequestInternal` method will get synchronized if this flag is "true". The best available session mutex will be used for the synchronization; ideally, this will be a mutex exposed by HttpSessionMutexListener.

  The session mutex is guaranteed to be the same object during the entire lifetime of the session, available under the key defined by the `SESSION_MUTEX_ATTRIBUTE` constant. It serves as a safe reference to synchronize on for locking on the current session.

  In many cases, the HttpSession reference itself is a safe mutex as well, since it will always be the same object reference for the same active logical session. However, this is not guaranteed across different servlet containers; the only 100% safe way is a session mutex.

  See Also:
    `HttpSessionMutexListener`, `WebUtils.getSessionMutex(javax.servlet.http.HttpSession)`

### setParameterNameDiscoverer

    public void setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer)

  Set the ParameterNameDiscoverer to use for resolving method parameter names if needed (e.g. for default attribute names). Default is a `LocalVariableTableParameterNameDiscoverer`.

### setIgnoreDefaultModelOnRedirect

    public void setIgnoreDefaultModelOnRedirect(boolean ignoreDefaultModelOnRedirect)

  By default the content of the "default" model is used both during rendering and redirect scenarios. Alternatively a controller method can declare a `RedirectAttributes` argument and use it to provide attributes for a redirect.

  Setting this flag to `true` guarantees the "default" model is never used in a redirect scenario even if a RedirectAttributes argument is not declared. Setting it to `false` means the "default" model may be used in a redirect if the controller method doesn't declare a RedirectAttributes argument.

  The default setting is `false` but new applications should consider setting it to `true`.

  See Also:
    `RedirectAttributes`

### setAsyncTaskExecutor

    public void setAsyncTaskExecutor(AsyncTaskExecutor taskExecutor)

  Set the AsyncTaskExecutor to use when a controller method returns a `Callable`.

  The default instance type is a `SimpleAsyncTaskExecutor`. It's recommended to change that default in production as the simple executor does not re-use threads.

### setAsyncRequestTimeout

    public void setAsyncRequestTimeout(long asyncRequestTimeout)

  Set the timeout for asynchronous request processing in milliseconds. When the timeout begins depends on the underlying async technology. With the Servlet 3 async support the timeout begins after the main processing thread has exited and has been returned to the container pool.

  If a value is not provided, the default timeout of the underlying async technology is used (10 seconds on Tomcat with Servlet 3 async).

### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)

  Callback that supplies the owning factory to a bean instance.

  Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

  A `ConfigurableBeanFactory` is expected for resolving expressions in method argument default values.

  Specified by:
    `setBeanFactory` in interface `BeanFactoryAware`
  Parameters:
    `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
  See Also:
    `BeanInitializationException`

### getBeanFactory

    protected ConfigurableBeanFactory getBeanFactory()

  Return the owning factory of this bean instance, or `null`.

### afterPropertiesSet

    public void afterPropertiesSet()

  Description copied from interface: `InitializingBean`
  Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

  This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`

### supportsInternal

    protected boolean supportsInternal(HandlerMethod handlerMethod)

  Always return `true` since any method argument and return value type will be processed in some way. A method argument not recognized by any HandlerMethodArgumentResolver is interpreted as a request parameter if it is a simple type, or as a model attribute otherwise. A return value not recognized by any HandlerMethodReturnValueHandler will be interpreted as a model attribute.

  Specified by:
    `supportsInternal` in class `AbstractHandlerMethodAdapter`
  Parameters:
    `handlerMethod` - the handler method to check
  Returns:
    whether or not this adapter can adapt the given method

### getLastModifiedInternal

    protected long getLastModifiedInternal(javax.servlet.http.HttpServletRequest request,
                                           HandlerMethod handlerMethod)

  This implementation always returns -1. An `@RequestMapping` method can calculate the lastModified value, call `WebRequest.checkNotModified(long)`, and return `null` if the result of that call is `true`.

  Specified by:
    `getLastModifiedInternal` in class `AbstractHandlerMethodAdapter`
  Parameters:
    `request` - current HTTP request
    `handlerMethod` - handler method to use
  Returns:
    the lastModified value for the given handler

### handleInternal

    protected final ModelAndView handleInternal(javax.servlet.http.HttpServletRequest request,
                                                javax.servlet.http.HttpServletResponse response,
                                                HandlerMethod handlerMethod)
                                         throws java.lang.Exception

  Description copied from class: `AbstractHandlerMethodAdapter`
  Use the given handler method to handle the request.

  Specified by:
    `handleInternal` in class `AbstractHandlerMethodAdapter`
  Parameters:
    `request` - current HTTP request
    `response` - current HTTP response
    `handlerMethod` - handler method to use. This object must have previously been passed to the `AbstractHandlerMethodAdapter.supportsInternal(HandlerMethod)` this interface, which must have returned `true`.
  Returns:
    ModelAndView object with the name of the view and the required model data, or `null` if the request has been handled directly
  Throws:
    `java.lang.Exception` - in case of errors

### createDataBinderFactory

    protected ServletRequestDataBinderFactory createDataBinderFactory(java.util.List<InvocableHandlerMethod> binderMethods)
                                                               throws java.lang.Exception

  Template method to create a new ServletRequestDataBinderFactory instance.

  The default implementation creates a ServletRequestDataBinderFactory. This can be overridden for custom ServletRequestDataBinder subclasses.

  Parameters:
    `binderMethods` - `@InitBinder` methods
  Returns:
    the ServletRequestDataBinderFactory instance to use
  Throws:
    `java.lang.Exception` - in case of invalid state or arguments

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD