org.springframework.web.servlet

## Class FrameworkServlet

- java.lang.Object
- - javax.servlet.GenericServlet
  - - javax.servlet.http.HttpServlet
    - - org.springframework.web.servlet.HttpServletBean
      - - org.springframework.web.servlet.FrameworkServlet

- All Implemented Interfaces:
    Serializable, Servlet, ServletConfig, Aware, ApplicationContextAware, EnvironmentAware, EnvironmentCapable
  Direct Known Subclasses:
    DispatcherServlet

      public abstract class FrameworkServlet
      extends HttpServletBean
      implements ApplicationContextAware

  Base servlet for Spring's web framework. Provides integration with a Spring application context, in a JavaBean-based overall solution.

  This class offers the following functionality:

  - Manages a `WebApplicationContext` instance per servlet. The servlet's configuration is determined by beans in the servlet's namespace.
  - Publishes events on request processing, whether or not a request is successfully handled.

  Subclasses must implement `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` to handle requests. Because this extends `HttpServletBean` rather than HttpServlet directly, bean properties are automatically mapped onto it. Subclasses can override `initFrameworkServlet()` for custom initialization.

  Detects a "contextClass" parameter at the servlet init-param level, falling back to the default context class, `XmlWebApplicationContext`, if not found. Note that, with the default `FrameworkServlet`, a custom context class needs to implement the `ConfigurableWebApplicationContext` SPI.

  Accepts an optional "contextInitializerClasses" servlet init-param that specifies one or more `ApplicationContextInitializer` classes. The managed web application context will be delegated to these initializers, allowing for additional programmatic configuration, e.g. adding property sources or activating profiles against the context's environment. See also `ContextLoader` which supports a "contextInitializerClasses" context-param with identical semantics for the "root" web application context.

  Passes a "contextConfigLocation" servlet init-param to the context instance, parsing it into potentially multiple file paths which can be separated by any number of commas and spaces, like "test-servlet.xml, myServlet.xml". If not explicitly specified, the context implementation is supposed to build a default location from the namespace of the servlet.

  Note: In case of multiple config locations, later bean definitions will override ones defined in earlier loaded files, at least when using Spring's default ApplicationContext implementation. This can be leveraged to deliberately override certain bean definitions via an extra XML file.

  The default namespace is "'servlet-name'-servlet", e.g. "test-servlet" for a servlet-name "test" (leading to a "/WEB-INF/test-servlet.xml" default location with XmlWebApplicationContext). The namespace can also be set explicitly via the "namespace" servlet init-param.

  As of Spring 3.1, `FrameworkServlet` may now be injected with a web application context, rather than creating its own internally. This is useful in Servlet 3.0+ environments, which support programmatic registration of servlet instances. See `FrameworkServlet(WebApplicationContext)` Javadoc for details.

  Author:
    Rod Johnson, Juergen Hoeller, Sam Brannen, Chris Beams, Rossen Stoyanchev, Phillip Webb
  See Also:
    `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, `setContextClass(java.lang.Class<?>)`, `setContextConfigLocation(java.lang.String)`, `setContextInitializerClasses(java.lang.String)`, `setNamespace(java.lang.String)`, Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Class<?>` | `DEFAULT_CONTEXT_CLASS` Default context class for FrameworkServlet.
    `static String` | `DEFAULT_NAMESPACE_SUFFIX` Suffix for WebApplicationContext namespaces.
    `static String` | `SERVLET_CONTEXT_PREFIX` Prefix for the ServletContext attribute for the WebApplicationContext.

    - ### Fields inherited from class org.springframework.web.servlet.HttpServletBean

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FrameworkServlet()` Create a new `FrameworkServlet` that will create its own internal web application context based on defaults and values provided through servlet init-params.
    `FrameworkServlet(WebApplicationContext webApplicationContext)` Create a new `FrameworkServlet` with the given web application context.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `applyInitializers(ConfigurableApplicationContext wac)` Delegate the WebApplicationContext before it is refreshed to any `ApplicationContextInitializer` instances specified by the "contextInitializerClasses" servlet init-param.
    `protected LocaleContext` | `buildLocaleContext(HttpServletRequest request)` Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
    `protected ServletRequestAttributes` | `buildRequestAttributes(HttpServletRequest request, HttpServletResponse response, RequestAttributes previousAttributes)` Build ServletRequestAttributes for the given request (potentially also holding a reference to the response), taking pre-bound attributes (and their type) into consideration.
    `protected void` | `configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac)`
    `protected WebApplicationContext` | `createWebApplicationContext(ApplicationContext parent)` Instantiate the WebApplicationContext for this servlet, either a default `XmlWebApplicationContext` or a `custom context class`, if set.
    `protected WebApplicationContext` | `createWebApplicationContext(WebApplicationContext parent)` Instantiate the WebApplicationContext for this servlet, either a default `XmlWebApplicationContext` or a `custom context class`, if set.
    `void` | `destroy()` Close the WebApplicationContext of this servlet.
    `protected void` | `doDelete(HttpServletRequest request, HttpServletResponse response)` Delegate DELETE requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
    `protected void` | `doGet(HttpServletRequest request, HttpServletResponse response)` Delegate GET requests to processRequest/doService.
    `protected void` | `doOptions(HttpServletRequest request, HttpServletResponse response)` Delegate OPTIONS requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, if desired.
    `protected void` | `doPost(HttpServletRequest request, HttpServletResponse response)` Delegate POST requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
    `protected void` | `doPut(HttpServletRequest request, HttpServletResponse response)` Delegate PUT requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
    `protected abstract void` | `doService(HttpServletRequest request, HttpServletResponse response)` Subclasses must implement this method to do the work of request handling, receiving a centralized callback for GET, POST, PUT and DELETE.
    `protected void` | `doTrace(HttpServletRequest request, HttpServletResponse response)` Delegate TRACE requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, if desired.
    `protected WebApplicationContext` | `findWebApplicationContext()` Retrieve a `WebApplicationContext` from the `ServletContext` attribute with the `configured name`.
    `String` | `getContextAttribute()` Return the name of the ServletContext attribute which should be used to retrieve the `WebApplicationContext` that this servlet is supposed to use.
    `Class<?>` | `getContextClass()` Return the custom context class.
    `String` | `getContextConfigLocation()` Return the explicit context config location, if any.
    `String` | `getContextId()` Return the custom WebApplicationContext id, if any.
    `String` | `getNamespace()` Return the namespace for this servlet, falling back to default scheme if no custom namespace was set: e.g.
    `String` | `getServletContextAttributeName()` Return the ServletContext attribute name for this servlet's WebApplicationContext.
    `protected String` | `getUsernameForRequest(HttpServletRequest request)` Determine the username for the given request.
    `WebApplicationContext` | `getWebApplicationContext()` Return this servlet's WebApplicationContext.
    `protected void` | `initFrameworkServlet()` This method will be invoked after any bean properties have been set and the WebApplicationContext has been loaded.
    `protected void` | `initServletBean()` Overridden method of `HttpServletBean`, invoked after any bean properties have been set.
    `protected WebApplicationContext` | `initWebApplicationContext()` Initialize and publish the WebApplicationContext for this servlet.
    `void` | `onApplicationEvent(ContextRefreshedEvent event)` Callback that receives refresh events from this servlet's WebApplicationContext.
    `protected void` | `onRefresh(ApplicationContext context)` Template method which can be overridden to add servlet-specific refresh work.
    `protected void` | `postProcessWebApplicationContext(ConfigurableWebApplicationContext wac)` Post-process the given WebApplicationContext before it is refreshed and activated as context for this servlet.
    `protected void` | `processRequest(HttpServletRequest request, HttpServletResponse response)` Process this request, publishing an event regardless of the outcome.
    `void` | `refresh()` Refresh this servlet's application context, as well as the dependent state of the servlet.
    `protected void` | `service(HttpServletRequest request, HttpServletResponse response)` Override the parent class implementation in order to intercept PATCH requests.
    `void` | `setApplicationContext(ApplicationContext applicationContext)` Called by Spring via `ApplicationContextAware` to inject the current application context.
    `void` | `setContextAttribute(String contextAttribute)` Set the name of the ServletContext attribute which should be used to retrieve the `WebApplicationContext` that this servlet is supposed to use.
    `void` | `setContextClass(Class<?> contextClass)` Set a custom context class.
    `void` | `setContextConfigLocation(String contextConfigLocation)` Set the context config location explicitly, instead of relying on the default location built from the namespace.
    `void` | `setContextId(String contextId)` Specify a custom WebApplicationContext id, to be used as serialization id for the underlying BeanFactory.
    `void` | `setContextInitializerClasses(String contextInitializerClasses)` Specify the set of fully-qualified `ApplicationContextInitializer` class names, per the optional "contextInitializerClasses" servlet init-param.
    `void` | `setContextInitializers(ApplicationContextInitializer<? extends ConfigurableApplicationContext>... contextInitializers)` Specify which `ApplicationContextInitializer` instances should be used to initialize the application context used by this `FrameworkServlet`.
    `void` | `setDispatchOptionsRequest(boolean dispatchOptionsRequest)` Set whether this servlet should dispatch an HTTP OPTIONS request to the `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` method.
    `void` | `setDispatchTraceRequest(boolean dispatchTraceRequest)` Set whether this servlet should dispatch an HTTP TRACE request to the `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` method.
    `void` | `setNamespace(String namespace)` Set a custom namespace for this servlet, to be used for building a default context config location.
    `void` | `setPublishContext(boolean publishContext)` Set whether to publish this servlet's context as a ServletContext attribute, available to all objects in the web container.
    `void` | `setPublishEvents(boolean publishEvents)` Set whether this servlet should publish a ServletRequestHandledEvent at the end of each request.
    `void` | `setThreadContextInheritable(boolean threadContextInheritable)` Set whether to expose the LocaleContext and RequestAttributes as inheritable for child threads (using an `InheritableThreadLocal`).

    - ### Methods inherited from class org.springframework.web.servlet.HttpServletBean

      `addRequiredProperty, createEnvironment, getEnvironment, getServletContext, getServletName, init, initBeanWrapper, setEnvironment`

    - ### Methods inherited from class javax.servlet.http.HttpServlet

      `doHead, getLastModified, service`

    - ### Methods inherited from class javax.servlet.GenericServlet

      `getInitParameter, getInitParameterNames, getServletConfig, getServletInfo, init, log, log`

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

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

- - ### Field Detail

    - #### DEFAULT_NAMESPACE_SUFFIX

          public static final String DEFAULT_NAMESPACE_SUFFIX

      Suffix for WebApplicationContext namespaces. If a servlet of this class is given the name "test" in a context, the namespace used by the servlet will resolve to "test-servlet".
      See Also:
        Constant Field Values

    - #### DEFAULT_CONTEXT_CLASS

          public static final Class<?> DEFAULT_CONTEXT_CLASS

      Default context class for FrameworkServlet.
      See Also:
        `XmlWebApplicationContext`

    - #### SERVLET_CONTEXT_PREFIX

          public static final String SERVLET_CONTEXT_PREFIX

      Prefix for the ServletContext attribute for the WebApplicationContext. The completion is the servlet name.

  - ### Constructor Detail

    - #### FrameworkServlet

          public FrameworkServlet()

      Create a new `FrameworkServlet` that will create its own internal web application context based on defaults and values provided through servlet init-params. Typically used in Servlet 2.5 or earlier environments, where the only option for servlet registration is through `web.xml` which requires the use of a no-arg constructor.

      Calling `setContextConfigLocation(java.lang.String)` (init-param 'contextConfigLocation') will dictate which XML files will be loaded by the default XmlWebApplicationContext

      Calling `setContextClass(java.lang.Class<?>)` (init-param 'contextClass') overrides the default `XmlWebApplicationContext` and allows for specifying an alternative class, such as `AnnotationConfigWebApplicationContext`.

      Calling `setContextInitializerClasses(java.lang.String)` (init-param 'contextInitializerClasses') indicates which `ApplicationContextInitializer` classes should be used to further configure the internal application context prior to refresh().

      See Also:
        `FrameworkServlet(WebApplicationContext)`

    - #### FrameworkServlet

          public FrameworkServlet(WebApplicationContext webApplicationContext)

      Create a new `FrameworkServlet` with the given web application context. This constructor is useful in Servlet 3.0+ environments where instance-based registration of servlets is possible through the `ServletContext.addServlet(java.lang.String, java.lang.String)` API.

      Using this constructor indicates that the following properties / init-params will be ignored:

      - `setContextClass(Class)` / 'contextClass'
      - `setContextConfigLocation(String)` / 'contextConfigLocation'
      - `setContextAttribute(String)` / 'contextAttribute'
      - `setNamespace(String)` / 'namespace'

      The given web application context may or may not yet be refreshed. If it (a) is an implementation of `ConfigurableWebApplicationContext` and (b) has not already been refreshed (the recommended approach), then the following will occur:

      - If the given context does not already have a parent, the root application context will be set as the parent.
      - If the given context has not already been assigned an id, one will be assigned to it
      - `ServletContext` and `ServletConfig` objects will be delegated to the application context
      - `postProcessWebApplicationContext(org.springframework.web.context.ConfigurableWebApplicationContext)` will be called
      - Any `ApplicationContextInitializer`s specified through the "contextInitializerClasses" init-param or through the `setContextInitializers(org.springframework.context.ApplicationContextInitializer<? extends org.springframework.context.ConfigurableApplicationContext>...)` property will be applied.
      - `refresh()` will be called
      If the context has already been refreshed or does not implement `ConfigurableWebApplicationContext`, none of the above will occur under the assumption that the user has performed these actions (or not) per his or her specific needs.

      See `WebApplicationInitializer` for usage examples.

      Parameters:
        `webApplicationContext` - the context to use
      See Also:
        `initWebApplicationContext()`, `configureAndRefreshWebApplicationContext(org.springframework.web.context.ConfigurableWebApplicationContext)`, `WebApplicationInitializer`

  - ### Method Detail

    - #### setContextAttribute

          public void setContextAttribute(String contextAttribute)

      Set the name of the ServletContext attribute which should be used to retrieve the `WebApplicationContext` that this servlet is supposed to use.

    - #### getContextAttribute

          public String getContextAttribute()

      Return the name of the ServletContext attribute which should be used to retrieve the `WebApplicationContext` that this servlet is supposed to use.

    - #### setContextClass

          public void setContextClass(Class<?> contextClass)

      Set a custom context class. This class must be of type `WebApplicationContext`.

      When using the default FrameworkServlet implementation, the context class must also implement the `ConfigurableWebApplicationContext` interface.

      See Also:
        `createWebApplicationContext(org.springframework.context.ApplicationContext)`

    - #### getContextClass

          public Class<?> getContextClass()

      Return the custom context class.

    - #### setContextId

          public void setContextId(String contextId)

      Specify a custom WebApplicationContext id, to be used as serialization id for the underlying BeanFactory.

    - #### getContextId

          public String getContextId()

      Return the custom WebApplicationContext id, if any.

    - #### setNamespace

          public void setNamespace(String namespace)

      Set a custom namespace for this servlet, to be used for building a default context config location.

    - #### getNamespace

          public String getNamespace()

      Return the namespace for this servlet, falling back to default scheme if no custom namespace was set: e.g. "test-servlet" for a servlet named "test".

    - #### setContextConfigLocation

          public void setContextConfigLocation(String contextConfigLocation)

      Set the context config location explicitly, instead of relying on the default location built from the namespace. This location string can consist of multiple locations separated by any number of commas and spaces.

    - #### getContextConfigLocation

          public String getContextConfigLocation()

      Return the explicit context config location, if any.

    - #### setContextInitializers

          public void setContextInitializers(ApplicationContextInitializer<? extends ConfigurableApplicationContext>... contextInitializers)

      Specify which `ApplicationContextInitializer` instances should be used to initialize the application context used by this `FrameworkServlet`.
      See Also:
        `configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext)`, `applyInitializers(ConfigurableApplicationContext)`

    - #### setContextInitializerClasses

          public void setContextInitializerClasses(String contextInitializerClasses)

      Specify the set of fully-qualified `ApplicationContextInitializer` class names, per the optional "contextInitializerClasses" servlet init-param.
      See Also:
        `configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext)`, `applyInitializers(ConfigurableApplicationContext)`

    - #### setPublishContext

          public void setPublishContext(boolean publishContext)

      Set whether to publish this servlet's context as a ServletContext attribute, available to all objects in the web container. Default is "true".

      This is especially handy during testing, although it is debatable whether it's good practice to let other application objects access the context this way.

    - #### setPublishEvents

          public void setPublishEvents(boolean publishEvents)

      Set whether this servlet should publish a ServletRequestHandledEvent at the end of each request. Default is "true"; can be turned off for a slight performance improvement, provided that no ApplicationListeners rely on such events.
      See Also:
        `ServletRequestHandledEvent`

    - #### setThreadContextInheritable

          public void setThreadContextInheritable(boolean threadContextInheritable)

      Set whether to expose the LocaleContext and RequestAttributes as inheritable for child threads (using an `InheritableThreadLocal`).

      Default is "false", to avoid side effects on spawned background threads. Switch this to "true" to enable inheritance for custom child threads which are spawned during request processing and only used for this request (that is, ending after their initial task, without reuse of the thread).

      WARNING: Do not use inheritance for child threads if you are accessing a thread pool which is configured to potentially add new threads on demand (e.g. a JDK `ThreadPoolExecutor`), since this will expose the inherited context to such a pooled thread.

    - #### setDispatchOptionsRequest

          public void setDispatchOptionsRequest(boolean dispatchOptionsRequest)

      Set whether this servlet should dispatch an HTTP OPTIONS request to the `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` method.

      Default is "false", applying `HttpServlet`'s default behavior (i.e. enumerating all standard HTTP request methods as a response to the OPTIONS request).

      Turn this flag on if you prefer OPTIONS requests to go through the regular dispatching chain, just like other HTTP requests. This usually means that your controllers will receive those requests; make sure that those endpoints are actually able to handle an OPTIONS request.

      Note that HttpServlet's default OPTIONS processing will be applied in any case if your controllers happen to not set the 'Allow' header (as required for an OPTIONS response).

    - #### setDispatchTraceRequest

          public void setDispatchTraceRequest(boolean dispatchTraceRequest)

      Set whether this servlet should dispatch an HTTP TRACE request to the `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` method.

      Default is "false", applying `HttpServlet`'s default behavior (i.e. reflecting the message received back to the client).

      Turn this flag on if you prefer TRACE requests to go through the regular dispatching chain, just like other HTTP requests. This usually means that your controllers will receive those requests; make sure that those endpoints are actually able to handle a TRACE request.

      Note that HttpServlet's default TRACE processing will be applied in any case if your controllers happen to not generate a response of content type 'message/http' (as required for a TRACE response).

    - #### setApplicationContext

          public void setApplicationContext(ApplicationContext applicationContext)

      Called by Spring via `ApplicationContextAware` to inject the current application context. This method allows FrameworkServlets to be registered as Spring beans inside an existing `WebApplicationContext` rather than `finding` a `bootstrapped` context.

      Primarily added to support use in embedded servlet containers.

      Specified by:
        `setApplicationContext` in interface `ApplicationContextAware`
      Parameters:
        `applicationContext` - the ApplicationContext object to be used by this object
      Since:
        4.0
      See Also:
        `BeanInitializationException`

    - #### initServletBean

          protected final void initServletBean()
                                        throws ServletException

      Overridden method of `HttpServletBean`, invoked after any bean properties have been set. Creates this servlet's WebApplicationContext.
      Overrides:
        `initServletBean` in class `HttpServletBean`
      Throws:
        `ServletException` - if subclass initialization fails

    - #### initWebApplicationContext

          protected WebApplicationContext initWebApplicationContext()

      Initialize and publish the WebApplicationContext for this servlet.

      Delegates to `createWebApplicationContext(org.springframework.context.ApplicationContext)` for actual creation of the context. Can be overridden in subclasses.

      Returns:
        the WebApplicationContext instance
      See Also:
        `FrameworkServlet(WebApplicationContext)`, `setContextClass(java.lang.Class<?>)`, `setContextConfigLocation(java.lang.String)`

    - #### findWebApplicationContext

          protected WebApplicationContext findWebApplicationContext()

      Retrieve a `WebApplicationContext` from the `ServletContext` attribute with the `configured name`. The `WebApplicationContext` must have already been loaded and stored in the `ServletContext` before this servlet gets initialized (or invoked).

      Subclasses may override this method to provide a different `WebApplicationContext` retrieval strategy.

      Returns:
        the WebApplicationContext for this servlet, or `null` if not found
      See Also:
        `getContextAttribute()`

    - #### createWebApplicationContext

          protected WebApplicationContext createWebApplicationContext(ApplicationContext parent)

      Instantiate the WebApplicationContext for this servlet, either a default `XmlWebApplicationContext` or a `custom context class`, if set.

      This implementation expects custom contexts to implement the `ConfigurableWebApplicationContext` interface. Can be overridden in subclasses.

      Do not forget to register this servlet instance as application listener on the created context (for triggering its `callback`, and to call `ConfigurableApplicationContext.refresh()` before returning the context instance.

      Parameters:
        `parent` - the parent ApplicationContext to use, or `null` if none
      Returns:
        the WebApplicationContext for this servlet
      See Also:
        `XmlWebApplicationContext`

    - #### configureAndRefreshWebApplicationContext

          protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac)

    - #### createWebApplicationContext

          protected WebApplicationContext createWebApplicationContext(WebApplicationContext parent)

      Instantiate the WebApplicationContext for this servlet, either a default `XmlWebApplicationContext` or a `custom context class`, if set. Delegates to #createWebApplicationContext(ApplicationContext).
      Parameters:
        `parent` - the parent WebApplicationContext to use, or `null` if none
      Returns:
        the WebApplicationContext for this servlet
      See Also:
        `XmlWebApplicationContext`, `createWebApplicationContext(ApplicationContext)`

    - #### postProcessWebApplicationContext

          protected void postProcessWebApplicationContext(ConfigurableWebApplicationContext wac)

      Post-process the given WebApplicationContext before it is refreshed and activated as context for this servlet.

      The default implementation is empty. `refresh()` will be called automatically after this method returns.

      Note that this method is designed to allow subclasses to modify the application context, while `initWebApplicationContext()` is designed to allow end-users to modify the context through the use of `ApplicationContextInitializer`s.

      Parameters:
        `wac` - the configured WebApplicationContext (not refreshed yet)
      See Also:
        `createWebApplicationContext(org.springframework.context.ApplicationContext)`, `initWebApplicationContext()`, `ConfigurableApplicationContext.refresh()`

    - #### applyInitializers

          protected void applyInitializers(ConfigurableApplicationContext wac)

      Delegate the WebApplicationContext before it is refreshed to any `ApplicationContextInitializer` instances specified by the "contextInitializerClasses" servlet init-param.

      See also `postProcessWebApplicationContext(org.springframework.web.context.ConfigurableWebApplicationContext)`, which is designed to allow subclasses (as opposed to end-users) to modify the application context, and is called immediately before this method.

      Parameters:
        `wac` - the configured WebApplicationContext (not refreshed yet)
      See Also:
        `createWebApplicationContext(org.springframework.context.ApplicationContext)`, `postProcessWebApplicationContext(org.springframework.web.context.ConfigurableWebApplicationContext)`, `ConfigurableApplicationContext.refresh()`

    - #### getServletContextAttributeName

          public String getServletContextAttributeName()

      Return the ServletContext attribute name for this servlet's WebApplicationContext.

      The default implementation returns `SERVLET_CONTEXT_PREFIX + servlet name`.

      See Also:
        `SERVLET_CONTEXT_PREFIX`, `HttpServletBean.getServletName()`

    - #### getWebApplicationContext

          public final WebApplicationContext getWebApplicationContext()

      Return this servlet's WebApplicationContext.

    - #### initFrameworkServlet

          protected void initFrameworkServlet()
                                       throws ServletException

      This method will be invoked after any bean properties have been set and the WebApplicationContext has been loaded. The default implementation is empty; subclasses may override this method to perform any initialization they require.
      Throws:
        `ServletException` - in case of an initialization exception

    - #### refresh

          public void refresh()

      Refresh this servlet's application context, as well as the dependent state of the servlet.
      See Also:
        `getWebApplicationContext()`, `ConfigurableApplicationContext.refresh()`

    - #### onApplicationEvent

          public void onApplicationEvent(ContextRefreshedEvent event)

      Callback that receives refresh events from this servlet's WebApplicationContext.

      The default implementation calls `onRefresh(org.springframework.context.ApplicationContext)`, triggering a refresh of this servlet's context-dependent state.

      Parameters:
        `event` - the incoming ApplicationContext event

    - #### onRefresh

          protected void onRefresh(ApplicationContext context)

      Template method which can be overridden to add servlet-specific refresh work. Called after successful context refresh.

      This implementation is empty.

      Parameters:
        `context` - the current WebApplicationContext
      See Also:
        `refresh()`

    - #### destroy

          public void destroy()

      Close the WebApplicationContext of this servlet.
      Specified by:
        `destroy` in interface `Servlet`
      Overrides:
        `destroy` in class `GenericServlet`
      See Also:
        `ConfigurableApplicationContext.close()`

    - #### service

          protected void service(HttpServletRequest request,
                                 HttpServletResponse response)
                          throws ServletException,
                                 IOException

      Override the parent class implementation in order to intercept PATCH requests.
      Overrides:
        `service` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`

    - #### doGet

          protected final void doGet(HttpServletRequest request,
                                     HttpServletResponse response)
                              throws ServletException,
                                     IOException

      Delegate GET requests to processRequest/doService.

      Will also be invoked by HttpServlet's default implementation of `doHead`, with a `NoBodyResponse` that just captures the content length.

      Overrides:
        `doGet` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, `HttpServlet.doHead(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### doPost

          protected final void doPost(HttpServletRequest request,
                                      HttpServletResponse response)
                               throws ServletException,
                                      IOException

      Delegate POST requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
      Overrides:
        `doPost` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### doPut

          protected final void doPut(HttpServletRequest request,
                                     HttpServletResponse response)
                              throws ServletException,
                                     IOException

      Delegate PUT requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
      Overrides:
        `doPut` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### doDelete

          protected final void doDelete(HttpServletRequest request,
                                        HttpServletResponse response)
                                 throws ServletException,
                                        IOException

      Delegate DELETE requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`.
      Overrides:
        `doDelete` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### doOptions

          protected void doOptions(HttpServletRequest request,
                                   HttpServletResponse response)
                            throws ServletException,
                                   IOException

      Delegate OPTIONS requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, if desired.

      Applies HttpServlet's standard OPTIONS processing otherwise, and also if there is still no 'Allow' header set after dispatching.

      Overrides:
        `doOptions` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### doTrace

          protected void doTrace(HttpServletRequest request,
                                 HttpServletResponse response)
                          throws ServletException,
                                 IOException

      Delegate TRACE requests to `processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, if desired.

      Applies HttpServlet's standard TRACE processing otherwise.

      Overrides:
        `doTrace` in class `HttpServlet`
      Throws:
        `ServletException`
        `IOException`
      See Also:
        `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`

    - #### processRequest

          protected final void processRequest(HttpServletRequest request,
                                              HttpServletResponse response)
                                       throws ServletException,
                                              IOException

      Process this request, publishing an event regardless of the outcome.

      The actual event handling is performed by the abstract `doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)` template method.

      Throws:
        `ServletException`
        `IOException`

    - #### buildLocaleContext

          protected LocaleContext buildLocaleContext(HttpServletRequest request)

      Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
      Parameters:
        `request` - current HTTP request
      Returns:
        the corresponding LocaleContext, or `null` if none to bind
      See Also:
        `LocaleContextHolder.setLocaleContext(org.springframework.context.i18n.LocaleContext)`

    - #### buildRequestAttributes

          protected ServletRequestAttributes buildRequestAttributes(HttpServletRequest request,
                                                                    HttpServletResponse response,
                                                                    RequestAttributes previousAttributes)

      Build ServletRequestAttributes for the given request (potentially also holding a reference to the response), taking pre-bound attributes (and their type) into consideration.
      Parameters:
        `request` - current HTTP request
        `response` - current HTTP response
        `previousAttributes` - pre-bound RequestAttributes instance, if any
      Returns:
        the ServletRequestAttributes to bind, or `null` to preserve the previously bound instance (or not binding any, if none bound before)
      See Also:
        `RequestContextHolder.setRequestAttributes(org.springframework.web.context.request.RequestAttributes)`

    - #### getUsernameForRequest

          protected String getUsernameForRequest(HttpServletRequest request)

      Determine the username for the given request.

      The default implementation takes the name of the UserPrincipal, if any. Can be overridden in subclasses.

      Parameters:
        `request` - current HTTP request
      Returns:
        the username, or `null` if none found
      See Also:
        `HttpServletRequest.getUserPrincipal()`

    - #### doService

          protected abstract void doService(HttpServletRequest request,
                                            HttpServletResponse response)
                                     throws Exception

      Subclasses must implement this method to do the work of request handling, receiving a centralized callback for GET, POST, PUT and DELETE.

      The contract is essentially the same as that for the commonly overridden `doGet` or `doPost` methods of HttpServlet.

      This class intercepts calls to ensure that exception handling and event publication takes place.

      Parameters:
        `request` - current HTTP request
        `response` - current HTTP response
      Throws:
        `Exception` - in case of any kind of processing failure
      See Also:
        `HttpServlet.doGet(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`, `HttpServlet.doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`