Open Source Repository

Home /spring/spring-web-servlet-3.0.5 | Repository Home



org/springframework/web/servlet/DispatcherServlet.java
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.i18n.LocaleContext;
import org.springframework.core.OrderComparator;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.ui.context.ThemeSource;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.util.NestedServletException;
import org.springframework.web.util.UrlPathHelper;
import org.springframework.web.util.WebUtils;

/**
 * Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service
 * exporters. Dispatches to registered handlers for processing a web request, providing convenient mapping and exception
 * handling facilities.
 *
 <p>This servlet is very flexible: It can be used with just about any workflow, with the installation of the
 * appropriate adapter classes. It offers the following functionality that distinguishes it from other request-driven
 * web MVC frameworks:
 *
 <ul> <li>It is based around a JavaBeans configuration mechanism.
 *
 <li>It can use any {@link HandlerMapping} implementation - pre-built or provided as part of an application - to
 * control the routing of requests to handler objects. Default is {@link org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping}
 * and {@link org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping}. HandlerMapping objects
 * can be defined as beans in the servlet's application context, implementing the HandlerMapping interface, overriding
 * the default HandlerMapping if present. HandlerMappings can be given any bean name (they are tested by type).
 *
 <li>It can use any {@link HandlerAdapter}; this allows for using any handler interface. Default adapters are {@link
 * org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter}{@link org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter},
 * for Spring's {@link org.springframework.web.HttpRequestHandler} and {@link org.springframework.web.servlet.mvc.Controller}
 * interfaces, respectively. A default {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter}
 * will be registered as well. HandlerAdapter objects can be added as beans in the application context, overriding the
 * default HandlerAdapters. Like HandlerMappings, HandlerAdapters can be given any bean name (they are tested by type).
 *
 <li>The dispatcher's exception resolution strategy can be specified via a {@link HandlerExceptionResolver}, for
 * example mapping certain exceptions to error pages. Default are
 {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver},
 {@link org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver}, and
 {@link org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver}. These HandlerExceptionResolvers can be overridden
 * through the application context. HandlerExceptionResolver can be given any bean name (they are tested by type).
 *
 <li>Its view resolution strategy can be specified via a {@link ViewResolver} implementation, resolving symbolic view
 * names into View objects. Default is {@link org.springframework.web.servlet.view.InternalResourceViewResolver}.
 * ViewResolver objects can be added as beans in the application context, overriding the default ViewResolver.
 * ViewResolvers can be given any bean name (they are tested by type).
 *
 <li>If a {@link View} or view name is not supplied by the user, then the configured {@link
 * RequestToViewNameTranslator} will translate the current request into a view name. The corresponding bean name is
 * "viewNameTranslator"; the default is {@link org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator}.
 *
 <li>The dispatcher's strategy for resolving multipart requests is determined by a {@link
 * org.springframework.web.multipart.MultipartResolver} implementation. Implementations for Jakarta Commons FileUpload
 * and Jason Hunter's COS are included; the typical choise is {@link org.springframework.web.multipart.commons.CommonsMultipartResolver}.
 * The MultipartResolver bean name is "multipartResolver"; default is none.
 *
 <li>Its locale resolution strategy is determined by a {@link LocaleResolver}. Out-of-the-box implementations work via
 * HTTP accept header, cookie, or session. The LocaleResolver bean name is "localeResolver"; default is {@link
 * org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver}.
 *
 <li>Its theme resolution strategy is determined by a {@link ThemeResolver}. Implementations for a fixed theme and for
 * cookie and session storage are included. The ThemeResolver bean name is "themeResolver"; default is {@link
 * org.springframework.web.servlet.theme.FixedThemeResolver}</ul>
 *
 <p><b>NOTE: The <code>@RequestMapping</code> annotation will only be processed if a corresponding
 <code>HandlerMapping</code> (for type level annotations) and/or <code>HandlerAdapter</code> (for method level
 * annotations) is present in the dispatcher.</b> This is the case by default. However, if you are defining custom
 <code>HandlerMappings</code> or <code>HandlerAdapters</code>, then you need to make sure that a corresponding custom
 <code>DefaultAnnotationHandlerMapping</code> and/or <code>AnnotationMethodHandlerAdapter</code> is defined as well -
 * provided that you intend to use <code>@RequestMapping</code>.
 *
 <p><b>A web application can define any number of DispatcherServlets.</b> Each servlet will operate in its own
 * namespace, loading its own application context with mappings, handlers, etc. Only the root application context as
 * loaded by {@link org.springframework.web.context.ContextLoaderListener}, if any, will be shared.
 *
 @author Rod Johnson
 @author Juergen Hoeller
 @author Rob Harrop
 @see org.springframework.web.HttpRequestHandler
 @see org.springframework.web.servlet.mvc.Controller
 @see org.springframework.web.context.ContextLoaderListener
 */
public class DispatcherServlet extends FrameworkServlet {

  /** Well-known name for the MultipartResolver object in the bean factory for this namespace. */
  public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";

  /** Well-known name for the LocaleResolver object in the bean factory for this namespace. */
  public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";

  /** Well-known name for the ThemeResolver object in the bean factory for this namespace. */
  public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";

  /**
   * Well-known name for the HandlerMapping object in the bean factory for this namespace.
   * Only used when "detectAllHandlerMappings" is turned off.
   @see #setDetectAllHandlerMappings
   */
  public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";

  /**
   * Well-known name for the HandlerAdapter object in the bean factory for this namespace.
   * Only used when "detectAllHandlerAdapters" is turned off.
   @see #setDetectAllHandlerAdapters
   */
  public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";

  /**
   * Well-known name for the HandlerExceptionResolver object in the bean factory for this namespace.
   * Only used when "detectAllHandlerExceptionResolvers" is turned off.
   @see #setDetectAllHandlerExceptionResolvers
   */
  public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";

  /**
   * Well-known name for the RequestToViewNameTranslator object in the bean factory for this namespace.
   */
  public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";

  /**
   * Well-known name for the ViewResolver object in the bean factory for this namespace.
   * Only used when "detectAllViewResolvers" is turned off.
   @see #setDetectAllViewResolvers
   */
  public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";

  /**
   * Request attribute to hold the current web application context.
   * Otherwise only the global web app context is obtainable by tags etc.
   @see org.springframework.web.servlet.support.RequestContextUtils#getWebApplicationContext
   */
  public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() ".CONTEXT";

  /**
   * Request attribute to hold the current LocaleResolver, retrievable by views.
   @see org.springframework.web.servlet.support.RequestContextUtils#getLocaleResolver
   */
  public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() ".LOCALE_RESOLVER";

  /**
   * Request attribute to hold the current ThemeResolver, retrievable by views.
   @see org.springframework.web.servlet.support.RequestContextUtils#getThemeResolver
   */
  public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() ".THEME_RESOLVER";

  /**
   * Request attribute to hold the current ThemeSource, retrievable by views.
   @see org.springframework.web.servlet.support.RequestContextUtils#getThemeSource
   */
  public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() ".THEME_SOURCE";

  /** Log category to use when no mapped handler is found for a request. */
  public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";

  /**
   * Name of the class path resource (relative to the DispatcherServlet class)
   * that defines DispatcherServlet's default strategy names.
   */
  private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";


  /** Additional logger to use when no mapped handler is found for a request. */
  protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);

  private static final UrlPathHelper urlPathHelper = new UrlPathHelper();

  private static final Properties defaultStrategies;

  static {
    // Load default strategy implementations from properties file.
    // This is currently strictly internal and not meant to be customized
    // by application developers.
    try {
      ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
      defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
    }
    catch (IOException ex) {
      throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
    }
  }

  /** Detect all HandlerMappings or just expect "handlerMapping" bean? */
  private boolean detectAllHandlerMappings = true;

  /** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
  private boolean detectAllHandlerAdapters = true;

  /** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
  private boolean detectAllHandlerExceptionResolvers = true;

  /** Detect all ViewResolvers or just expect "viewResolver" bean? */
  private boolean detectAllViewResolvers = true;

  /** Perform cleanup of request attributes after include request? */
  private boolean cleanupAfterInclude = true;

  /** MultipartResolver used by this servlet */
  private MultipartResolver multipartResolver;

  /** LocaleResolver used by this servlet */
  private LocaleResolver localeResolver;

  /** ThemeResolver used by this servlet */
  private ThemeResolver themeResolver;

  /** List of HandlerMappings used by this servlet */
  private List<HandlerMapping> handlerMappings;

  /** List of HandlerAdapters used by this servlet */
  private List<HandlerAdapter> handlerAdapters;

  /** List of HandlerExceptionResolvers used by this servlet */
  private List<HandlerExceptionResolver> handlerExceptionResolvers;

  /** RequestToViewNameTranslator used by this servlet */
  private RequestToViewNameTranslator viewNameTranslator;

  /** List of ViewResolvers used by this servlet */
  private List<ViewResolver> viewResolvers;


  /**
   * Set whether to detect all HandlerMapping beans in this servlet's context. Otherwise,
   * just a single bean with name "handlerMapping" will be expected.
   <p>Default is "true". Turn this off if you want this servlet to use a single
   * HandlerMapping, despite multiple HandlerMapping beans being defined in the context.
   */
  public void setDetectAllHandlerMappings(boolean detectAllHandlerMappings) {
    this.detectAllHandlerMappings = detectAllHandlerMappings;
  }

  /**
   * Set whether to detect all HandlerAdapter beans in this servlet's context. Otherwise,
   * just a single bean with name "handlerAdapter" will be expected.
   <p>Default is "true". Turn this off if you want this servlet to use a single
   * HandlerAdapter, despite multiple HandlerAdapter beans being defined in the context.
   */
  public void setDetectAllHandlerAdapters(boolean detectAllHandlerAdapters) {
    this.detectAllHandlerAdapters = detectAllHandlerAdapters;
  }

  /**
   * Set whether to detect all HandlerExceptionResolver beans in this servlet's context. Otherwise,
   * just a single bean with name "handlerExceptionResolver" will be expected.
   <p>Default is "true". Turn this off if you want this servlet to use a single
   * HandlerExceptionResolver, despite multiple HandlerExceptionResolver beans being defined in the context.
   */
  public void setDetectAllHandlerExceptionResolvers(boolean detectAllHandlerExceptionResolvers) {
    this.detectAllHandlerExceptionResolvers = detectAllHandlerExceptionResolvers;
  }

  /**
   * Set whether to detect all ViewResolver beans in this servlet's context. Otherwise,
   * just a single bean with name "viewResolver" will be expected.
   <p>Default is "true". Turn this off if you want this servlet to use a single
   * ViewResolver, despite multiple ViewResolver beans being defined in the context.
   */
  public void setDetectAllViewResolvers(boolean detectAllViewResolvers) {
    this.detectAllViewResolvers = detectAllViewResolvers;
  }

  /**
   * Set whether to perform cleanup of request attributes after an include request, that is,
   * whether to reset the original state of all request attributes after the DispatcherServlet
   * has processed within an include request. Otherwise, just the DispatcherServlet's own
   * request attributes will be reset, but not model attributes for JSPs or special attributes
   * set by views (for example, JSTL's).
   <p>Default is "true", which is strongly recommended. Views should not rely on request attributes
   * having been set by (dynamic) includes. This allows JSP views rendered by an included controller
   * to use any model attributes, even with the same names as in the main JSP, without causing side
   * effects. Only turn this off for special needs, for example to deliberately allow main JSPs to
   * access attributes from JSP views rendered by an included controller.
   */
  public void setCleanupAfterInclude(boolean cleanupAfterInclude) {
    this.cleanupAfterInclude = cleanupAfterInclude;
  }

  /**
   * This implementation calls {@link #initStrategies}.
   */
  @Override
  protected void onRefresh(ApplicationContext context) {
    initStrategies(context);
  }

  /**
   * Initialize the strategy objects that this servlet uses.
   <p>May be overridden in subclasses in order to initialize further strategy objects.
   */
  protected void initStrategies(ApplicationContext context) {
    initMultipartResolver(context);
    initLocaleResolver(context);
    initThemeResolver(context);
    initHandlerMappings(context);
    initHandlerAdapters(context);
    initHandlerExceptionResolvers(context);
    initRequestToViewNameTranslator(context);
    initViewResolvers(context);
  }

  /**
   * Initialize the MultipartResolver used by this class.
   <p>If no bean is defined with the given name in the BeanFactory for this namespace,
   * no multipart handling is provided.
   */
  private void initMultipartResolver(ApplicationContext context) {
    try {
      this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using MultipartResolver [" this.multipartResolver + "]");
      }
    }
    catch (NoSuchBeanDefinitionException ex) {
      // Default is no multipart resolver.
      this.multipartResolver = null;
      if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
            "': no multipart request handling provided");
      }
    }
  }

  /**
   * Initialize the LocaleResolver used by this class.
   <p>If no bean is defined with the given name in the BeanFactory for this namespace,
   * we default to AcceptHeaderLocaleResolver.
   */
  private void initLocaleResolver(ApplicationContext context) {
    try {
      this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using LocaleResolver [" this.localeResolver + "]");
      }
    }
    catch (NoSuchBeanDefinitionException ex) {
      // We need to use the default.
      this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate LocaleResolver with name '" + LOCALE_RESOLVER_BEAN_NAME +
            "': using default [" this.localeResolver + "]");
      }
    }
  }

  /**
   * Initialize the ThemeResolver used by this class.
   <p>If no bean is defined with the given name in the BeanFactory for this namespace,
   * we default to a FixedThemeResolver.
   */
  private void initThemeResolver(ApplicationContext context) {
    try {
      this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using ThemeResolver [" this.themeResolver + "]");
      }
    }
    catch (NoSuchBeanDefinitionException ex) {
      // We need to use the default.
      this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Unable to locate ThemeResolver with name '" + THEME_RESOLVER_BEAN_NAME + "': using default [" +
                this.themeResolver + "]");
      }
    }
  }

  /**
   * Initialize the HandlerMappings used by this class.
   <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
   * we default to BeanNameUrlHandlerMapping.
   */
  private void initHandlerMappings(ApplicationContext context) {
    this.handlerMappings = null;

    if (this.detectAllHandlerMappings) {
      // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
      Map<String, HandlerMapping> matchingBeans =
          BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
      if (!matchingBeans.isEmpty()) {
        this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
        // We keep HandlerMappings in sorted order.
        OrderComparator.sort(this.handlerMappings);
      }
    }
    else {
      try {
        HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
        this.handlerMappings = Collections.singletonList(hm);
      }
      catch (NoSuchBeanDefinitionException ex) {
        // Ignore, we'll add a default HandlerMapping later.
      }
    }

    // Ensure we have at least one HandlerMapping, by registering
    // a default HandlerMapping if no other mappings are found.
    if (this.handlerMappings == null) {
      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
      if (logger.isDebugEnabled()) {
        logger.debug("No HandlerMappings found in servlet '" + getServletName() "': using default");
      }
    }
  }

  /**
   * Initialize the HandlerAdapters used by this class.
   <p>If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
   * we default to SimpleControllerHandlerAdapter.
   */
  private void initHandlerAdapters(ApplicationContext context) {
    this.handlerAdapters = null;

    if (this.detectAllHandlerAdapters) {
      // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
      Map<String, HandlerAdapter> matchingBeans =
          BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
      if (!matchingBeans.isEmpty()) {
        this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
        // We keep HandlerAdapters in sorted order.
        OrderComparator.sort(this.handlerAdapters);
      }
    }
    else {
      try {
        HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
        this.handlerAdapters = Collections.singletonList(ha);
      }
      catch (NoSuchBeanDefinitionException ex) {
        // Ignore, we'll add a default HandlerAdapter later.
      }
    }

    // Ensure we have at least some HandlerAdapters, by registering
    // default HandlerAdapters if no other adapters are found.
    if (this.handlerAdapters == null) {
      this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
      if (logger.isDebugEnabled()) {
        logger.debug("No HandlerAdapters found in servlet '" + getServletName() "': using default");
      }
    }
  }

  /**
   * Initialize the HandlerExceptionResolver used by this class.
   <p>If no bean is defined with the given name in the BeanFactory for this namespace,
   * we default to no exception resolver.
   */
  private void initHandlerExceptionResolvers(ApplicationContext context) {
    this.handlerExceptionResolvers = null;

    if (this.detectAllHandlerExceptionResolvers) {
      // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
      Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
          .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
      if (!matchingBeans.isEmpty()) {
        this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
        // We keep HandlerExceptionResolvers in sorted order.
        OrderComparator.sort(this.handlerExceptionResolvers);
      }
    }
    else {
      try {
        HandlerExceptionResolver her =
            context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
        this.handlerExceptionResolvers = Collections.singletonList(her);
      }
      catch (NoSuchBeanDefinitionException ex) {
        // Ignore, no HandlerExceptionResolver is fine too.
      }
    }

    // Ensure we have at least some HandlerExceptionResolvers, by registering
    // default HandlerExceptionResolvers if no other resolvers are found.
    if (this.handlerExceptionResolvers == null) {
      this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("No HandlerExceptionResolvers found in servlet '" + getServletName() "': using default");
      }
    }
  }

  /**
   * Initialize the RequestToViewNameTranslator used by this servlet instance.
   <p>If no implementation is configured then we default to DefaultRequestToViewNameTranslator.
   */
  private void initRequestToViewNameTranslator(ApplicationContext context) {
    try {
      this.viewNameTranslator =
          context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using RequestToViewNameTranslator [" this.viewNameTranslator + "]");
      }
    }
    catch (NoSuchBeanDefinitionException ex) {
      // We need to use the default.
      this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate RequestToViewNameTranslator with name '" +
            REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME + "': using default [" this.viewNameTranslator +
            "]");
      }
    }
  }

  /**
   * Initialize the ViewResolvers used by this class.
   <p>If no ViewResolver beans are defined in the BeanFactory for this
   * namespace, we default to InternalResourceViewResolver.
   */
  private void initViewResolvers(ApplicationContext context) {
    this.viewResolvers = null;

    if (this.detectAllViewResolvers) {
      // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
      Map<String, ViewResolver> matchingBeans =
          BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
      if (!matchingBeans.isEmpty()) {
        this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());
        // We keep ViewResolvers in sorted order.
        OrderComparator.sort(this.viewResolvers);
      }
    }
    else {
      try {
        ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
        this.viewResolvers = Collections.singletonList(vr);
      }
      catch (NoSuchBeanDefinitionException ex) {
        // Ignore, we'll add a default ViewResolver later.
      }
    }

    // Ensure we have at least one ViewResolver, by registering
    // a default ViewResolver if no other resolvers are found.
    if (this.viewResolvers == null) {
      this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
      if (logger.isDebugEnabled()) {
        logger.debug("No ViewResolvers found in servlet '" + getServletName() "': using default");
      }
    }
  }

  /**
   * Return this servlet's ThemeSource, if any; else return <code>null</code>.
   <p>Default is to return the WebApplicationContext as ThemeSource,
   * provided that it implements the ThemeSource interface.
   @return the ThemeSource, if any
   @see #getWebApplicationContext()
   */
  public final ThemeSource getThemeSource() {
    if (getWebApplicationContext() instanceof ThemeSource) {
      return (ThemeSourcegetWebApplicationContext();
    }
    else {
      return null;
    }
  }

  /**
   * Obtain this servlet's MultipartResolver, if any.
   @return the MultipartResolver used by this servlet, or <code>null</code> if none
   * (indicating that no multipart support is available)
   */
  public final MultipartResolver getMultipartResolver() {
    return this.multipartResolver;
  }

  /**
   * Return the default strategy object for the given strategy interface.
   <p>The default implementation delegates to {@link #getDefaultStrategies},
   * expecting a single object in the list.
   @param context the current WebApplicationContext
   @param strategyInterface the strategy interface
   @return the corresponding strategy object
   @see #getDefaultStrategies
   */
  protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
    List<T> strategies = getDefaultStrategies(context, strategyInterface);
    if (strategies.size() != 1) {
      throw new BeanInitializationException(
          "DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() "]");
    }
    return strategies.get(0);
  }

  /**
   * Create a List of default strategy objects for the given strategy interface.
   <p>The default implementation uses the "DispatcherServlet.properties" file (in the same
   * package as the DispatcherServlet class) to determine the class names. It instantiates
   * the strategy objects through the context's BeanFactory.
   @param context the current WebApplicationContext
   @param strategyInterface the strategy interface
   @return the List of corresponding strategy objects
   */
  @SuppressWarnings("unchecked")
  protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
    String key = strategyInterface.getName();
    String value = defaultStrategies.getProperty(key);
    if (value != null) {
      String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
      List<T> strategies = new ArrayList<T>(classNames.length);
      for (String className : classNames) {
        try {
          Class clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
          Object strategy = createDefaultStrategy(context, clazz);
          strategies.add((Tstrategy);
        }
        catch (ClassNotFoundException ex) {
          throw new BeanInitializationException(
              "Could not find DispatcherServlet's default strategy class [" + className +
                  "] for interface [" + key + "]", ex);
        }
        catch (LinkageError err) {
          throw new BeanInitializationException(
              "Error loading DispatcherServlet's default strategy class [" + className +
                  "] for interface [" + key + "]: problem with class file or dependent class", err);
        }
      }
      return strategies;
    }
    else {
      return new LinkedList<T>();
    }
  }

  /**
   * Create a default strategy.
   <p>The default implementation uses {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean}.
   @param context the current WebApplicationContext
   @param clazz the strategy implementation class to instantiate
   @return the fully configured strategy instance
   @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
   @see org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean
   */
  protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
    return context.getAutowireCapableBeanFactory().createBean(clazz);
  }

  /**
   * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
   * for the actual dispatching.
   */
  @Override
  protected void doService(HttpServletRequest request, HttpServletResponse responsethrows Exception {
    if (logger.isDebugEnabled()) {
      String requestUri = urlPathHelper.getRequestUri(request);
      logger.debug("DispatcherServlet with name '" + getServletName() "' processing " + request.getMethod() +
          " request for [" + requestUri + "]");
    }

    // Keep a snapshot of the request attributes in case of an include,
    // to be able to restore the original attributes after the include.
    Map<String, Object> attributesSnapshot = null;
    if (WebUtils.isIncludeRequest(request)) {
      logger.debug("Taking snapshot of request attributes before include");
      attributesSnapshot = new HashMap<String, Object>();
      Enumeration attrNames = request.getAttributeNames();
      while (attrNames.hasMoreElements()) {
        String attrName = (StringattrNames.nextElement();
        if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
          attributesSnapshot.put(attrName, request.getAttribute(attrName));
        }
      }
    }

    // Make framework objects available to handlers and view objects.
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

    try {
      doDispatch(request, response);
    }
    finally {
      // Restore the original attribute snapshot, in case of an include.
      if (attributesSnapshot != null) {
        restoreAttributesAfterInclude(request, attributesSnapshot);
      }
    }
  }

  /**
   * Process the actual dispatching to the handler.
   <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
   * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
   * to find the first that supports the handler class.
   <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
   * themselves to decide which methods are acceptable.
   @param request current HTTP request
   @param response current HTTP response
   @throws Exception in case of any kind of processing failure
   */
  protected void doDispatch(HttpServletRequest request, HttpServletResponse responsethrows Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    int interceptorIndex = -1;

    try {
      ModelAndView mv;
      boolean errorView = false;

      try {
        processedRequest = checkMultipart(request);

        // Determine handler for the current request.
        mappedHandler = getHandler(processedRequest, false);
        if (mappedHandler == null || mappedHandler.getHandler() == null) {
          noHandlerFound(processedRequest, response);
          return;
        }

        // Determine handler adapter for the current request.
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
        String method = request.getMethod();
        boolean isGet = "GET".equals(method);
        if (isGet || "HEAD".equals(method)) {
          long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
          if (logger.isDebugEnabled()) {
            String requestUri = urlPathHelper.getRequestUri(request);
            logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
          }
          if (new ServletWebRequest(request, response).checkNotModified(lastModified&& isGet) {
            return;
          }
        }

        // Apply preHandle methods of registered interceptors.
        HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
        if (interceptors != null) {
          for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
              triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
              return;
            }
            interceptorIndex = i;
          }
        }

        // Actually invoke the handler.
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

        // Do we need view name translation?
        if (mv != null && !mv.hasView()) {
          mv.setViewName(getDefaultViewName(request));
        }

        // Apply postHandle methods of registered interceptors.
        if (interceptors != null) {
          for (int i = interceptors.length - 1; i >= 0; i--) {
            HandlerInterceptor interceptor = interceptors[i];
            interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
          }
        }
      }
      catch (ModelAndViewDefiningException ex) {
        logger.debug("ModelAndViewDefiningException encountered", ex);
        mv = ex.getModelAndView();
      }
      catch (Exception ex) {
        Object handler = (mappedHandler != null ? mappedHandler.getHandler() null);
        mv = processHandlerException(processedRequest, response, handler, ex);
        errorView = (mv != null);
      }

      // Did the handler return a view to render?
      if (mv != null && !mv.wasCleared()) {
        render(mv, processedRequest, response);
        if (errorView) {
          WebUtils.clearErrorRequestAttributes(request);
        }
      }
      else {
        if (logger.isDebugEnabled()) {
          logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
              "': assuming HandlerAdapter completed request handling");
        }
      }

      // Trigger after-completion for successful outcome.
      triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
    }

    catch (Exception ex) {
      // Trigger after-completion for thrown exception.
      triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
      throw ex;
    }
    catch (Error err) {
      ServletException ex = new NestedServletException("Handler processing failed", err);
      // Trigger after-completion for thrown exception.
      triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
      throw ex;
    }

    finally {
      // Clean up any resources used by a multipart request.
      if (processedRequest != request) {
        cleanupMultipart(processedRequest);
      }
    }
  }

  /**
   * Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
   <p>The default implementation uses the dispatcher's LocaleResolver to obtain the current locale,
   * which might change during a request.
   @param request current HTTP request
   @return the corresponding LocaleContext
   */
  @Override
  protected LocaleContext buildLocaleContext(final HttpServletRequest request) {
    return new LocaleContext() {
      public Locale getLocale() {
        return localeResolver.resolveLocale(request);
      }
      @Override
      public String toString() {
        return getLocale().toString();
      }
    };
  }

  /**
   * Convert the request into a multipart request, and make multipart resolver available.
   <p>If no multipart resolver is set, simply use the existing request.
   @param request current HTTP request
   @return the processed request (multipart wrapper if necessary)
   @see MultipartResolver#resolveMultipart
   */
  protected HttpServletRequest checkMultipart(HttpServletRequest requestthrows MultipartException {
    if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
      if (request instanceof MultipartHttpServletRequest) {
        logger.debug("Request is already a MultipartHttpServletRequest - if not in a forward, " +
            "this typically results from an additional MultipartFilter in web.xml");
      }
      else {
        return this.multipartResolver.resolveMultipart(request);
      }
    }
    // If not returned before: return original request.
    return request;
  }

  /**
   * Clean up any resources used by the given multipart request (if any).
   @param request current HTTP request
   @see MultipartResolver#cleanupMultipart
   */
  protected void cleanupMultipart(HttpServletRequest request) {
    if (request instanceof MultipartHttpServletRequest) {
      this.multipartResolver.cleanupMultipart((MultipartHttpServletRequestrequest);
    }
  }

  /**
   * Return the HandlerExecutionChain for this request. Try all handler mappings in order.
   @param request current HTTP request
   @param cache whether to cache the HandlerExecutionChain in a request attribute
   @return the HandlerExecutionChain, or <code>null</code> if no handler could be found
   @deprecated as of Spring 3.0.4, in favor of {@link #getHandler(javax.servlet.http.HttpServletRequest)},
   * with this method's cache attribute now effectively getting ignored
   */
  @Deprecated
  protected HandlerExecutionChain getHandler(HttpServletRequest request, boolean cachethrows Exception {
    return getHandler(request);
  }

  /**
   * Return the HandlerExecutionChain for this request.
   <p>Tries all handler mappings in order.
   @param request current HTTP request
   @return the HandlerExecutionChain, or <code>null</code> if no handler could be found
   */
  protected HandlerExecutionChain getHandler(HttpServletRequest requestthrows Exception {
    for (HandlerMapping hm : this.handlerMappings) {
      if (logger.isTraceEnabled()) {
        logger.trace(
            "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() "'");
      }
      HandlerExecutionChain handler = hm.getHandler(request);
      if (handler != null) {
        return handler;
      }
    }
    return null;
  }

  /**
   * No handler found -> set appropriate HTTP response status.
   @param request current HTTP request
   @param response current HTTP response
   @throws Exception if preparing the response failed
   */
  protected void noHandlerFound(HttpServletRequest request, HttpServletResponse responsethrows Exception {
    if (pageNotFoundLogger.isWarnEnabled()) {
      String requestUri = urlPathHelper.getRequestUri(request);
      pageNotFoundLogger.warn("No mapping found for HTTP request with URI [" + requestUri +
          "] in DispatcherServlet with name '" + getServletName() "'");
    }
    response.sendError(HttpServletResponse.SC_NOT_FOUND);
  }

  /**
   * Return the HandlerAdapter for this handler object.
   @param handler the handler object to find an adapter for
   @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
   */
  protected HandlerAdapter getHandlerAdapter(Object handlerthrows ServletException {
    for (HandlerAdapter ha : this.handlerAdapters) {
      if (logger.isTraceEnabled()) {
        logger.trace("Testing handler adapter [" + ha + "]");
      }
      if (ha.supports(handler)) {
        return ha;
      }
    }
    throw new ServletException("No adapter for handler [" + handler +
        "]: Does your handler implement a supported interface like Controller?");
  }

  /**
   * Determine an error ModelAndView via the registered HandlerExceptionResolvers.
   @param request current HTTP request
   @param response current HTTP response
   @param handler the executed handler, or <code>null</code> if none chosen at the time of the exception
   * (for example, if multipart resolution failed)
   @param ex the exception that got thrown during handler execution
   @return a corresponding ModelAndView to forward to
   @throws Exception if no error ModelAndView found
   */
  protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
      Object handler, Exception exthrows Exception {

    // Check registered HandlerExceptionResolvers...
    ModelAndView exMv = null;
    for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
      exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
      if (exMv != null) {
        break;
      }
    }
    if (exMv != null) {
      if (exMv.isEmpty()) {
        return null;
      }
      // We might still need view name translation for a plain error model...
      if (!exMv.hasView()) {
        exMv.setViewName(getDefaultViewName(request));
      }
      if (logger.isDebugEnabled()) {
        logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);
      }
      WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
      return exMv;
    }

    throw ex;
  }

  /**
   * Render the given ModelAndView.
   <p>This is the last stage in handling a request. It may involve resolving the view by name.
   @param mv the ModelAndView to render
   @param request current HTTP servlet request
   @param response current HTTP servlet response
   @throws ServletException if view is missing or cannot be resolved
   @throws Exception if there's a problem rendering the view
   */
  protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse responsethrows Exception {
    // Determine locale for request and apply it to the response.
    Locale locale = this.localeResolver.resolveLocale(request);
    response.setLocale(locale);

    View view;
    if (mv.isReference()) {
      // We need to resolve the view name.
      view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
      if (view == null) {
        throw new ServletException(
            "Could not resolve view with name '" + mv.getViewName() "' in servlet with name '" +
                getServletName() "'");
      }
    }
    else {
      // No need to lookup: the ModelAndView object contains the actual View object.
      view = mv.getView();
      if (view == null) {
        throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
            "View object in servlet with name '" + getServletName() "'");
      }
    }

    // Delegate to the View object for rendering.
    if (logger.isDebugEnabled()) {
      logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() "'");
    }
    view.render(mv.getModelInternal(), request, response);
  }

  /**
   * Translate the supplied request into a default view name.
   @param request current HTTP servlet request
   @return the view name (or <code>null</code> if no default found)
   @throws Exception if view name translation failed
   */
  protected String getDefaultViewName(HttpServletRequest requestthrows Exception {
    return this.viewNameTranslator.getViewName(request);
  }

  /**
   * Resolve the given view name into a View object (to be rendered).
   <p>The default implementations asks all ViewResolvers of this dispatcher.
   * Can be overridden for custom resolution strategies, potentially based on
   * specific model attributes or request parameters.
   @param viewName the name of the view to resolve
   @param model the model to be passed to the view
   @param locale the current locale
   @param request current HTTP servlet request
   @return the View object, or <code>null</code> if none found
   @throws Exception if the view cannot be resolved
   * (typically in case of problems creating an actual View object)
   @see ViewResolver#resolveViewName
   */
  protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,
      HttpServletRequest requestthrows Exception {

    for (ViewResolver viewResolver : this.viewResolvers) {
      View view = viewResolver.resolveViewName(viewName, locale);
      if (view != null) {
        return view;
      }
    }
    return null;
  }

  /**
   * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
   * Will just invoke afterCompletion for all interceptors whose preHandle invocation
   * has successfully completed and returned true.
   @param mappedHandler the mapped HandlerExecutionChain
   @param interceptorIndex index of last interceptor that successfully completed
   @param ex Exception thrown on handler execution, or <code>null</code> if none
   @see HandlerInterceptor#afterCompletion
   */
  private void triggerAfterCompletion(HandlerExecutionChain mappedHandler,
      int interceptorIndex,
      HttpServletRequest request,
      HttpServletResponse response,
      Exception exthrows Exception {

    // Apply afterCompletion methods of registered interceptors.
    if (mappedHandler != null) {
      HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
      if (interceptors != null) {
        for (int i = interceptorIndex; i >= 0; i--) {
          HandlerInterceptor interceptor = interceptors[i];
          try {
            interceptor.afterCompletion(request, response, mappedHandler.getHandler(), ex);
          }
          catch (Throwable ex2) {
            logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
          }
        }
      }
    }
  }

  /**
   * Restore the request attributes after an include.
   @param request current HTTP request
   @param attributesSnapshot the snapshot of the request attributes before the include
   */
  private void restoreAttributesAfterInclude(HttpServletRequest request, Map attributesSnapshot) {
    logger.debug("Restoring snapshot of request attributes after include");

    // Need to copy into separate Collection here, to avoid side effects
    // on the Enumeration when removing attributes.
    Set<String> attrsToCheck = new HashSet<String>();
    Enumeration attrNames = request.getAttributeNames();
    while (attrNames.hasMoreElements()) {
      String attrName = (StringattrNames.nextElement();
      if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
        attrsToCheck.add(attrName);
      }
    }

    // Iterate over the attributes to check, restoring the original value
    // or removing the attribute, respectively, if appropriate.
    for (String attrName : attrsToCheck) {
      Object attrValue = attributesSnapshot.get(attrName);
      if (attrValue == null){
        if (logger.isDebugEnabled()) {
          logger.debug("Removing attribute [" + attrName + "] after include");
        }
        request.removeAttribute(attrName);
      }
      else if (attrValue != request.getAttribute(attrName)) {
        if (logger.isDebugEnabled()) {
          logger.debug("Restoring original value of attribute [" + attrName + "] after include");
        }
        request.setAttribute(attrName, attrValue);
      }
    }
  }

}