spring源码：DispatcherServlet-SpringMvc的servlet分派器

最新推荐文章于 2021-05-11 20:42:19 发布

czl315

最新推荐文章于 2021-05-11 20:42:19 发布

阅读量470

点赞数

分类专栏： spring源代码文章标签： spring源代码

本文链接：https://blog.csdn.net/czl315/article/details/103151858

版权

spring源代码专栏收录该内容

2 篇文章 0 订阅

订阅专栏

DispatcherServlet

package org.springframework.web.servlet;

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.ConfigurableApplicationContext;
import org.springframework.context.i18n.LocaleContext;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.lang.Nullable;
import org.springframework.ui.context.ThemeSource;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.async.WebAsyncManager;
import org.springframework.web.context.request.async.WebAsyncUtils;
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.WebUtils;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

/**

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.
HTTP请求handlers/controllers的中央分派器，例如,web的用户界面控制器、基于http的远程服务导出器。
分派给已注册的处理器处理web请求，提供方便的映射和异常处理设施
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:
这个servlet非常灵活:它可以与任何工作流一起使用，只需安装适当的适配器类。它提供了以下功能，将其与其他请求驱动的web MVC框架区分开来
It is based around a JavaBeans configuration mechanism.
它基于JavaBeans配置机制。
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.method.annotation.RequestMappingHandlerMapping}.
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).
*它可以使用任何{@link HandlerMapping}实现(预先构建或作为应用程序的一部分提供)来控制请求到处理程序对象的路由。
默认 * {@link org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping} and
- {@link org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping}.
HandlerMapping对象可以在servlet的应用程序上下文中定义为bean，实现HandlerMapping接口，
如果存在，则覆盖默认的HandlerMapping。HandlerMappings可以提供任何bean名称(它们通过类型进行测试)。
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.method.annotation.RequestMappingHandlerAdapter}
- 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).
它可以使用任何{@link HandlerAdapter};这允许使用任何处理程序接口。
默认的适配器是
{@link org.springframework.web.servlet.mvc。HttpRequestHandlerAdapter}，
{@link org.springframework.web.servlet.mvc。SimpleControllerHandlerAdapter}，
用于Spring的* {@link org.springframework.web。HttpRequestHandler}
{@link org.springframework.web.servlet.mvc。控制器}接口,分别。默认
{@link org.springframework.web.servlet.mvc.method.annotation。RequestMappingHandlerAdapter} 也将被注册。
HandlerAdapter对象可以作为bean添加到应用程序上下文中，覆盖默认的HandlerAdapter。
与HandlerMappings一样，可以为* * handleradapter提供任何bean名称(它们通过类型进行测试)。
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.method.annotation.ExceptionHandlerExceptionResolver},
{@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).
调度程序的异常解决策略可以通过{@link HandlerExceptionResolver}，
例如，将某些异常映射到错误页面。
可以在应用程序上下文中重写这些HandlerExceptionResolvers。HandlerExceptionResolver可以被赋予任何bean名(它们是通过类型来测试的)。
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).
它的视图解析策略可以通过{@link ViewResolver} *实现指定，将符号视图名解析为视图对象。
默认是* {@link org.springframework.web.servlet.view.InternalResourceViewResolver}。
ViewResolver对象可以作为bean添加到应用程序上下文中，
覆盖默认的ViewResolver。ViewResolvers可以被赋予任何bean名称(它们是通过类型来测试的)。
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}.
如果用户没有提供{@link View}或视图名，则配置的* {@link RequestToViewNameTranslator}将把当前请求转换为视图名。
对应的bean名是“viewNameTranslator”;默认是* {@link org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
The dispatcher's strategy for resolving multipart requests is determined by a
{@link org.springframework.web.multipart.MultipartResolver} implementation.
Implementations for Apache Commons FileUpload and Servlet 3 are included; the typical
choice is {@link org.springframework.web.multipart.commons.CommonsMultipartResolver}.
The MultipartResolver bean name is “multipartResolver”; default is none.
调度程序解决多部分请求的策略由一个* {@link org.springframework.web.multipart 决定。MultipartResolver}的实现。
包括Apache Commons FileUpload和Servlet 3的实现;典型的选择是{@link org.springframework.web.multipart.commons.CommonsMultipartResolver}。 MultipartResolver bean名是“MultipartResolver”;默认是没有的
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}.
它的地区解析策略由{@link LocaleResolver}决定。开箱即用的实现通过HTTP accept头、cookie或会话来工作。
- LocaleResolver bean名是“LocaleResolver”;默认是* {@link org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver}。
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}.
它的主题解析策略由{@link ThemeResolver}决定。实现一个固定的主题和cookie和会话存储包括在内。 ThemeResolver bean的名称是“ThemeResolver”;

NOTE: The {@code @RequestMapping} annotation will only be processed if a
corresponding {@code HandlerMapping} (for type-level annotations) and/or
{@code HandlerAdapter} (for method-level annotations) is present in the dispatcher.
This is the case by default. However, if you are defining custom {@code HandlerMappings}
or {@code HandlerAdapters}, then you need to make sure that a corresponding custom
{@code RequestMappingHandlerMapping} and/or {@code RequestMappingHandlerAdapter}
is defined as well - provided that you intend to use {@code @RequestMapping}.
只有当一个*对应的{@code HandlerMapping}被处理时，才会处理{@code @RequestMapping}注释
A web application can define any number of DispatcherServlets.
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.
Web 应用程序可以定义任意数量的 DispatcherServlets。 / b * 每个 servlet 将在自己的名称空间中运行，
用映射、处理程序等加载自己的应用程序上下文 * 。
只有由 * {@link org.springframework.web.context.ContextLoaderListener} 加载的根应用程序上下文。如果有的话，也是共享的。
As of Spring 3.1, {@code DispatcherServlet} 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 the {@link #DispatcherServlet(WebApplicationContext)} javadoc for details.
在 Spring 3.1中，{@code DispatcherServlet }现在可以被注入到 web 应用程序上下文中，而不是在内部创建自己的上下文。
这在 Servlet 3.0 + 环境中很有用，它支持 Servlet 实例的编程注册。
有关详细信息，请参阅{@link # dispatcherservlet (WebApplicationContext)} javadoc
@author Rod Johnson
@author Juergen Hoeller
@author Rob Harrop
@author Chris Beams
@author Rossen Stoyanchev
@see org.springframework.web.HttpRequestHandler
@see org.springframework.web.servlet.mvc.Controller
@see org.springframework.web.context.ContextLoaderListener
*/
@SuppressWarnings(“serial”)
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”;
/**
- Well-known name for the FlashMapManager object in the bean factory for this namespace.
  */
  public static final String FLASH_MAP_MANAGER_BEAN_NAME = “flashMapManager”;
/**
- 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#findWebApplicationContext
  */
  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”;
/**
- Name of request attribute that holds a read-only {@code Map<String,?>}
- with “input” flash attributes saved by a previous request, if any.
- @see org.springframework.web.servlet.support.RequestContextUtils#getInputFlashMap(HttpServletRequest)
  */
  public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + “.INPUT_FLASH_MAP”;
/**
- Name of request attribute that holds the “output” {@link FlashMap} with
- attributes to save for a subsequent request.
- @see org.springframework.web.servlet.support.RequestContextUtils#getOutputFlashMap(HttpServletRequest)
  */
  public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + “.OUTPUT_FLASH_MAP”;
/**
- Name of request attribute that holds the {@link FlashMapManager}.
- @see org.springframework.web.servlet.support.RequestContextUtils#getFlashMapManager(HttpServletRequest)
  */
  public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + “.FLASH_MAP_MANAGER”;
/**
- Name of request attribute that exposes an Exception resolved with an
- {@link HandlerExceptionResolver} but where no view was rendered
- (e.g. setting the status code).
  */
  public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + “.EXCEPTION”;
/** 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”;
/**
- Common prefix that DispatcherServlet’s default strategy attributes start with.
  */
  private static final String DEFAULT_STRATEGIES_PREFIX = “org.springframework.web.servlet”;
/** 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 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 '” + DEFAULT_STRATEGIES_PATH + "’: " + 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;

/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
private boolean throwExceptionIfNoHandlerFound = false;

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

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

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

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

/** List of HandlerMappings used by this servlet */
@Nullable
private List handlerMappings;

/** List of HandlerAdapters used by this servlet */
@Nullable
private List handlerAdapters;

/** List of HandlerExceptionResolvers used by this servlet */
@Nullable
private List handlerExceptionResolvers;

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

/** FlashMapManager used by this servlet */
@Nullable
private FlashMapManager flashMapManager;

/** List of ViewResolvers used by this servlet */
@Nullable
private List viewResolvers;

/**
- Create a new {@code DispatcherServlet} 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 {@code web.xml} which requires the use
- of a no-arg constructor.
- Calling {@link #setContextConfigLocation} (init-param 'contextConfigLocation')
- will dictate which XML files will be loaded by the
- {@linkplain #DEFAULT_CONTEXT_CLASS default XmlWebApplicationContext}
- Calling {@link #setContextClass} (init-param 'contextClass') overrides the
- default {@code XmlWebApplicationContext} and allows for specifying an alternative class,
- such as {@code AnnotationConfigWebApplicationContext}.
- Calling {@link #setContextInitializerClasses} (init-param 'contextInitializerClasses')
- indicates which {@code ApplicationContextInitializer} classes should be used to
- further configure the internal application context prior to refresh().
- @see #DispatcherServlet(WebApplicationContext)
  */
  public DispatcherServlet() {
  super();
  setDispatchOptionsRequest(true);
  }
/**
- Create a new {@code DispatcherServlet} 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 {@link ServletContext#addServlet} API.
- Using this constructor indicates that the following properties / init-params
- will be ignored:
- {@link #setContextClass(Class)} / 'contextClass'
{@link #setContextConfigLocation(String)} / 'contextConfigLocation'
{@link #setContextAttribute(String)} / 'contextAttribute'
{@link #setNamespace(String)} / 'namespace'
The given web application context may or may not yet be {@linkplain
ConfigurableApplicationContext#refresh() refreshed}. If it has not
already been refreshed (the recommended approach), then the following will occur:
If the given context does not already have a {@linkplain
ConfigurableApplicationContext#setParent parent}, the root application context
will be set as the parent.
If the given context has not already been assigned an {@linkplain
ConfigurableApplicationContext#setId id}, one will be assigned to it
{@code ServletContext} and {@code ServletConfig} objects will be delegated to
the application context
{@link #postProcessWebApplicationContext} will be called
Any {@code ApplicationContextInitializer}s specified through the
“contextInitializerClasses” init-param or through the {@link
#setContextInitializers} property will be applied.
{@link ConfigurableApplicationContext#refresh refresh()} will be called if the
context implements {@link ConfigurableApplicationContext}
If the context has already been refreshed, none of the above will occur, under the
assumption that the user has performed these actions (or not) per their specific
needs.
See {@link org.springframework.web.WebApplicationInitializer} for usage examples.
@param webApplicationContext the context to use
@see #initWebApplicationContext
@see #configureAndRefreshWebApplicationContext
@see org.springframework.web.WebApplicationInitializer
*/
public DispatcherServlet(WebApplicationContext webApplicationContext) {
super(webApplicationContext);
setDispatchOptionsRequest(true);
}
/**
- Set whether to detect all HandlerMapping beans in this servlet’s context. Otherwise,
- just a single bean with name “handlerMapping” will be expected.
- 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.
- 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.
- 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.
- 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 throw a NoHandlerFoundException when no Handler was found for this request.
- This exception can then be caught with a HandlerExceptionResolver or an
- {@code @ExceptionHandler} controller method.
- Note that if {@link org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler}
- is used, then requests will always be forwarded to the default servlet and a
- NoHandlerFoundException would never be thrown in that case.
- Default is "false", meaning the DispatcherServlet sends a NOT_FOUND error through the
- Servlet response.
- @since 4.0
  */
  public void setThrowExceptionIfNoHandlerFound(boolean throwExceptionIfNoHandlerFound) {
  this.throwExceptionIfNoHandlerFound = throwExceptionIfNoHandlerFound;
  }
/**
- 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).
- 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.
- May be overridden in subclasses in order to initialize further strategy objects.
*/
//初始化策略
protected void initStrategies(ApplicationContext context) {
//多文件上传的组件
initMultipartResolver(context);
//初始化本地语言环境
initLocaleResolver(context);
//初始化模板处理器
initThemeResolver(context);
//handlerMapping
initHandlerMappings(context);
//初始化参数适配器
initHandlerAdapters(context);
//初始化异常拦截器
initHandlerExceptionResolvers(context);
//初始化视图预处理器
initRequestToViewNameTranslator(context);
//初始化视图转换器
initViewResolvers(context);
//
initFlashMapManager(context);
}

/**
- Initialize the MultipartResolver used by this class.
- 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.
- 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.
- 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.
- 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<>(matchingBeans.values());
  // We keep HandlerMappings in sorted order.
  AnnotationAwareOrderComparator.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.
- 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<>(matchingBeans.values());
  // We keep HandlerAdapters in sorted order.
  AnnotationAwareOrderComparator.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.
- 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<>(matchingBeans.values());
  // We keep HandlerExceptionResolvers in sorted order.
  AnnotationAwareOrderComparator.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.
- 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.
- 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<>(matchingBeans.values());
  // We keep ViewResolvers in sorted order.
  AnnotationAwareOrderComparator.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”);
  }
  }
  }
/**
- Initialize the {@link FlashMapManager} used by this servlet instance.
- If no implementation is configured then we default to
- {@code org.springframework.web.servlet.support.DefaultFlashMapManager}.
  */
  private void initFlashMapManager(ApplicationContext context) {
  try {
  this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
  if (logger.isDebugEnabled()) {
  logger.debug(“Using FlashMapManager [” + this.flashMapManager + “]”);
  }
  }
  catch (NoSuchBeanDefinitionException ex) {
  // We need to use the default.
  this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
  if (logger.isDebugEnabled()) {
  logger.debug(“Unable to locate FlashMapManager with name '” +
  FLASH_MAP_MANAGER_BEAN_NAME + “’: using default [” + this.flashMapManager + “]”);
  }
  }
  }
/**
- Return this servlet’s ThemeSource, if any; else return {@code null}.
- Default is to return the WebApplicationContext as ThemeSource,
- provided that it implements the ThemeSource interface.
- @return the ThemeSource, if any
- @see #getWebApplicationContext()
  */
  @Nullable
  public final ThemeSource getThemeSource() {
  return (getWebApplicationContext() instanceof ThemeSource ? (ThemeSource) getWebApplicationContext() : null);
  }
/**
- Obtain this servlet’s MultipartResolver, if any.
- @return the MultipartResolver used by this servlet, or {@code null} if none
- (indicating that no multipart support is available)
  */
  @Nullable
  public final MultipartResolver getMultipartResolver() {
  return this.multipartResolver;
  }
/**
- Return the configured {@link HandlerMapping} beans that were detected by
- type in the {@link WebApplicationContext} or initialized based on the
- default set of strategies from {@literal DispatcherServlet.properties}.
- Note: This method may return {@code null} if invoked
- prior to {@link #onRefresh(ApplicationContext)}.
- @return an immutable list with the configured mappings, or {@code null}
- if not initialized yet
- @since 5.0
  */
  @Nullable
  public final List getHandlerMappings() {
  return (this.handlerMappings != null ? Collections.unmodifiableList(this.handlerMappings) : null);
  }
/**
- Return the default strategy object for the given strategy interface.
- 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 getDefaultStrategy(ApplicationContext context, Class strategyInterface) {
  List 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.
- 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 List getDefaultStrategies(ApplicationContext context, Class strategyInterface) {
  String key = strategyInterface.getName();
  String value = defaultStrategies.getProperty(key);
  if (value != null) {
  String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
  List strategies = new ArrayList<>(classNames.length);
  for (String className : classNames) {
  try {
  Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
  Object strategy = createDefaultStrategy(context, clazz);
  strategies.add((T) strategy);
  }
  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<>();
  }
  }
/**
- Create a default strategy.
- 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 response) throws Exception {
  if (logger.isDebugEnabled()) {
  String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : “”;
  logger.debug(“DispatcherServlet with name '” + getServletName() + “’” + resumed +
  " processing " + request.getMethod() + " request for [" + getRequestUri(request) + “]”);
  }
  
  // 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)) {
  attributesSnapshot = new HashMap<>();
  Enumeration<?> attrNames = request.getAttributeNames();
  while (attrNames.hasMoreElements()) {
  String attrName = (String) attrNames.nextElement();
  if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
  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());
  
  if (this.flashMapManager != null) {
  FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
  if (inputFlashMap != null) {
  request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
  }
  request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
  request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
  }
  
  try {
  doDispatch(request, response);
  }
  finally {
  if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
  // Restore the original attribute snapshot, in case of an include.
  if (attributesSnapshot != null) {
  restoreAttributesAfterInclude(request, attributesSnapshot);
  }
  }
  }
  }
/**
- Process the actual dispatching to the handler.
- 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.
- 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 response) throws Exception {
  HttpServletRequest processedRequest = request;
  HandlerExecutionChain mappedHandler = null;
  boolean multipartRequestParsed = false;
  
  WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  
  try {
  ModelAndView mv = null;
  Exception dispatchException = null;
```
 try {
 	// 1.检查是否是文件上传的请求
 	processedRequest = checkMultipart(request);
 	multipartRequestParsed = (processedRequest != request);

 	// Determine handler for the current request.
 	// 2.取得处理当前请求的controller,这里也称为hanlder,处理器,
 	// 	 第一个步骤的意义就在这里体现了.这里并不是直接返回controller,
 	//	 而是返回的HandlerExecutionChain请求处理器链对象,
 	//	 该对象封装了handler和interceptors.
 	mappedHandler = getHandler(processedRequest);
 	// 如果handler为空,则返回404
 	if (mappedHandler == null) {
 		noHandlerFound(processedRequest, response);
 		return;
 	}

 	// Determine handler adapter for the current request.
 	//3. 获取处理request的处理器适配器handler adapter
 	HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

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

 	if (!mappedHandler.applyPreHandle(processedRequest, response)) {
 		return;
 	}

 	// Actually invoke the handler.
 	// 4.实际的处理器处理请求,返回结果视图对象
 	mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

 	if (asyncManager.isConcurrentHandlingStarted()) {
 		return;
 	}

 	// 结果视图对象的处理
 	applyDefaultViewName(processedRequest, mv);
 	mappedHandler.applyPostHandle(processedRequest, response, mv);
 }
 catch (Exception ex) {
 	dispatchException = ex;
 }
 catch (Throwable err) {
 	// As of 4.3, we're processing Errors thrown from handler methods as well,
 	// making them available for @ExceptionHandler methods and other scenarios.
 	dispatchException = new NestedServletException("Handler dispatch failed", err);
 }
 processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
```
  }
  catch (Exception ex) {
  triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  }
  catch (Throwable err) {
  triggerAfterCompletion(processedRequest, response, mappedHandler,
  new NestedServletException(“Handler processing failed”, err));
  }
  finally {
  if (asyncManager.isConcurrentHandlingStarted()) {
  // Instead of postHandle and afterCompletion
  if (mappedHandler != null) {
  // 请求成功响应之后的方法
  mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  }
  }
  else {
  // Clean up any resources used by a multipart request.
  if (multipartRequestParsed) {
  cleanupMultipart(processedRequest);
  }
  }
  }
  }
/**
- Do we need view name translation?
  */
  private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
  if (mv != null && !mv.hasView()) {
  String defaultViewName = getDefaultViewName(request);
  if (defaultViewName != null) {
  mv.setViewName(defaultViewName);
  }
  }
  }
/**
- Handle the result of handler selection and handler invocation, which is
- either a ModelAndView or an Exception to be resolved to a ModelAndView.
  */
  private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
  @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
  @Nullable Exception exception) throws Exception {
  
  boolean errorView = false;
  
  if (exception != null) {
  if (exception instanceof ModelAndViewDefiningException) {
  logger.debug(“ModelAndViewDefiningException encountered”, exception);
  mv = ((ModelAndViewDefiningException) exception).getModelAndView();
  }
  else {
  Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  mv = processHandlerException(request, response, handler, exception);
  errorView = (mv != null);
  }
  }
  
  // Did the handler return a view to render?
  if (mv != null && !mv.wasCleared()) {
  render(mv, request, 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”);
  }
  }
  
  if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
  // Concurrent handling started during a forward
  return;
  }
  
  if (mappedHandler != null) {
  mappedHandler.triggerAfterCompletion(request, response, null);
  }
  }
/**
- Build a LocaleContext for the given request, exposing the request’s primary locale as current locale.
- 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) {
  LocaleResolver lr = this.localeResolver;
  if (lr instanceof LocaleContextResolver) {
  return ((LocaleContextResolver) lr).resolveLocaleContext(request);
  }
  else {
  return () -> (lr != null ? lr.resolveLocale(request) : request.getLocale());
  }
  }
/**
- Convert the request into a multipart request, and make multipart resolver available.
- 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 request) throws MultipartException {
  if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
  if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {
  logger.debug("Request is already a MultipartHttpServletRequest - if not in a forward, " +
  “this typically results from an additional MultipartFilter in web.xml”);
  }
  else if (hasMultipartException(request) ) {
  logger.debug("Multipart resolution failed for current request before - " +
  “skipping re-resolution for undisturbed error rendering”);
  }
  else {
  try {
  return this.multipartResolver.resolveMultipart(request);
  }
  catch (MultipartException ex) {
  if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) != null) {
  logger.debug(“Multipart resolution failed for error dispatch”, ex);
  // Keep processing error dispatch with regular request handle below
  }
  else {
  throw ex;
  }
  }
  }
  }
  // If not returned before: return original request.
  return request;
  }
/**
- Check “javax.servlet.error.exception” attribute for a multipart exception.
  */
  private boolean hasMultipartException(HttpServletRequest request) {
  Throwable error = (Throwable) request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE);
  while (error != null) {
  if (error instanceof MultipartException) {
  return true;
  }
  error = error.getCause();
  }
  return false;
  }
/**
- 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 (this.multipartResolver != null) {
  MultipartHttpServletRequest multipartRequest =
  WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
  if (multipartRequest != null) {
  this.multipartResolver.cleanupMultipart(multipartRequest);
  }
  }
  }
/**
- Return the HandlerExecutionChain for this request.
- Tries all handler mappings in order.
- @param request current HTTP request
- @return the HandlerExecutionChain, or {@code null} if no handler could be found
  */
  @Nullable
  protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  if (this.handlerMappings != null) {
  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 response) throws Exception {
  if (pageNotFoundLogger.isWarnEnabled()) {
  pageNotFoundLogger.warn(“No mapping found for HTTP request with URI [” + getRequestUri(request) +
  “] in DispatcherServlet with name '” + getServletName() + “’”);
  }
  if (this.throwExceptionIfNoHandlerFound) {
  throw new NoHandlerFoundException(request.getMethod(), getRequestUri(request),
  new ServletServerHttpRequest(request).getHeaders());
  }
  else {
  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 handler) throws ServletException {
  if (this.handlerAdapters != null) {
  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 +
  “]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler”);
  }
/**
- 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} 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
  */
  @Nullable
  protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
  @Nullable Object handler, Exception ex) throws Exception {
  
  // Check registered HandlerExceptionResolvers…
  ModelAndView exMv = null;
  if (this.handlerExceptionResolvers != null) {
  for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
  exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
  if (exMv != null) {
  break;
  }
  }
  }
  if (exMv != null) {
  if (exMv.isEmpty()) {
  request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
  return null;
  }
  // We might still need view name translation for a plain error model…
  if (!exMv.hasView()) {
  String defaultViewName = getDefaultViewName(request);
  if (defaultViewName != null) {
  exMv.setViewName(defaultViewName);
  }
  }
  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.
- 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 response) throws Exception {
  // Determine locale for request and apply it to the response.
  Locale locale =
  (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
  response.setLocale(locale);
  
  View view;
  String viewName = mv.getViewName();
  if (viewName != null) {
  // We need to resolve the view name.
  view = resolveViewName(viewName, 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() + “’”);
  }
  try {
  if (mv.getStatus() != null) {
  response.setStatus(mv.getStatus().value());
  }
  view.render(mv.getModelInternal(), request, response);
  }
  catch (Exception ex) {
  if (logger.isDebugEnabled()) {
  logger.debug(“Error rendering view [” + view + “] in DispatcherServlet with name '” +
  getServletName() + “’”, ex);
  }
  throw ex;
  }
  }
/**
- Translate the supplied request into a default view name.
- @param request current HTTP servlet request
- @return the view name (or {@code null} if no default found)
- @throws Exception if view name translation failed
  */
  @Nullable
  protected String getDefaultViewName(HttpServletRequest request) throws Exception {
  return (this.viewNameTranslator != null ? this.viewNameTranslator.getViewName(request) : null);
  }
/**
- Resolve the given view name into a View object (to be rendered).
- 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} if none found
- @throws Exception if the view cannot be resolved
- (typically in case of problems creating an actual View object)
- @see ViewResolver#resolveViewName
  */
  @Nullable
  protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
  Locale locale, HttpServletRequest request) throws Exception {
  
  if (this.viewResolvers != null) {
  for (ViewResolver viewResolver : this.viewResolvers) {
  View view = viewResolver.resolveViewName(viewName, locale);
  if (view != null) {
  return view;
  }
  }
  }
  return null;
  }
private void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, Exception ex) throws Exception {
```
 if (mappedHandler != null) {
 	mappedHandler.triggerAfterCompletion(request, response, ex);
 }
 throw ex;
```
}

/**
- Restore the request attributes after an include.
- @param request current HTTP request
- @param attributesSnapshot the snapshot of the request attributes before the include
  */
  @SuppressWarnings(“unchecked”)
  private void restoreAttributesAfterInclude(HttpServletRequest request, Map<?,?> attributesSnapshot) {
  // Need to copy into separate Collection here, to avoid side effects
  // on the Enumeration when removing attributes.
  Set attrsToCheck = new HashSet<>();
  Enumeration<?> attrNames = request.getAttributeNames();
  while (attrNames.hasMoreElements()) {
  String attrName = (String) attrNames.nextElement();
  if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
  attrsToCheck.add(attrName);
  }
  }
  
  // Add attributes that may have been removed
  attrsToCheck.addAll((Set) attributesSnapshot.keySet());
  
  // 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){
  request.removeAttribute(attrName);
  }
  else if (attrValue != request.getAttribute(attrName)) {
  request.setAttribute(attrName, attrValue);
  }
  }
  }
private static String getRequestUri(HttpServletRequest request) {
String uri = (String) request.getAttribute(WebUtils.INCLUDE_REQUEST_URI_ATTRIBUTE);
if (uri == null) {
uri = request.getRequestURI();
}
return uri;
}

}

czl315

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
spring源码：DispatcherServlet-SpringMvc的servlet分派器

DispatcherServlet/*Copyright 2002-2017 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 Licen...
复制链接

扫一扫