org.springframework.web.servlet.mvc

## Class AbstractController

- 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.AbstractController

- All Implemented Interfaces:
    Aware, ApplicationContextAware, ServletContextAware, Controller
  Direct Known Subclasses:
    AbstractUrlViewController, BaseCommandController, MultiActionController, ParameterizableViewController, ServletForwardingController, ServletWrappingController

      public abstract class AbstractController
      extends WebContentGenerator
      implements Controller

  Convenient superclass for controller implementations, using the Template Method design pattern.

  As stated in the `Controller` interface, a lot of functionality is already provided by certain abstract base controllers. The AbstractController is one of the most important abstract base controller providing basic features such as the generation of caching headers and the enabling or disabling of supported methods (GET/POST).

  Workflow (and that defined by interface):

  1. `handleRequest()` will be called by the DispatcherServlet
  2. Inspection of supported methods (ServletException if request method is not support)
  3. If session is required, try to get it (ServletException if not found)
  4. Set caching headers if needed according to the cacheSeconds property
  5. Call abstract method `handleRequestInternal()` (optionally synchronizing around the call on the HttpSession), which should be implemented by extending classes to provide actual functionality to return `ModelAndView` objects.

  Exposed configuration properties (and those defined by interface):

  name | default | description
  supportedMethods | GET,POST | comma-separated (CSV) list of methods supported by this controller, such as GET, POST and PUT
  requireSession | false | whether a session should be required for requests to be able to be handled by this controller. This ensures that derived controller can - without fear of null pointers - call request.getSession() to retrieve a session. If no session can be found while processing the request, a ServletException will be thrown
  cacheSeconds | -1 | indicates the amount of seconds to include in the cache header for the response following on this request. 0 (zero) will include headers for no caching at all, -1 (the default) will not generate any headers and any positive number will generate headers that state the amount indicated as seconds to cache the content
  synchronizeOnSession | false | whether the call to `handleRequestInternal` should be synchronized around the HttpSession, to serialize invocations from the same client. No effect if there is no HttpSession.

  Author:
    Rod Johnson, Juergen Hoeller
  See Also:
    `WebContentInterceptor`

- - ### Field Summary

    - ### 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`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractController()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ModelAndView` | `handleRequest(HttpServletRequest request, HttpServletResponse response)` Process the request and return a ModelAndView object which the DispatcherServlet will render.
    `protected abstract ModelAndView` | `handleRequestInternal(HttpServletRequest request, HttpServletResponse response)` Template method.
    `boolean` | `isSynchronizeOnSession()` Return whether controller execution should be synchronized on the session.
    `void` | `setSynchronizeOnSession(boolean synchronizeOnSession)` Set if controller execution should be synchronized on the session, to serialize parallel invocations from the same client.

    - ### 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`

- - ### Constructor Detail

    - #### AbstractController

          public AbstractController()

  - ### Method Detail

    - #### setSynchronizeOnSession

          public final 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:
        `handleRequestInternal(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, `HttpSessionMutexListener`, `WebUtils.getSessionMutex(javax.servlet.http.HttpSession)`

    - #### isSynchronizeOnSession

          public final boolean isSynchronizeOnSession()

      Return whether controller execution should be synchronized on the session.

    - #### handleRequest

          public ModelAndView handleRequest(HttpServletRequest request,
                                   HttpServletResponse response)
                                     throws Exception

      Description copied from interface: `Controller`
      Process the request and return a ModelAndView object which the DispatcherServlet will render. A `null` return value is not an error: It indicates that this object completed request processing itself, thus there is no ModelAndView to render.
      Specified by:
        `handleRequest` in interface `Controller`
      Parameters:
        `request` - current HTTP request
        `response` - current HTTP response
      Returns:
        a ModelAndView to render, or `null` if handled directly
      Throws:
        `Exception` - in case of errors

    - #### handleRequestInternal

          protected abstract ModelAndView handleRequestInternal(HttpServletRequest request,
                                           HttpServletResponse response)
                                                         throws Exception

      Template method. Subclasses must implement this. The contract is the same as for `handleRequest`.
      Throws:
        `Exception`
      See Also:
        `handleRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`