目录

• • • • 一、名词解析
      • 二、get接口调用栈帧图
      • 三、工作流程
      • 四、总结
      • 五、流程图
      • 六、源码
      • • DispatcherServlet.java源码

一、名词解析

• 1.DispatcherServlet [dɪˈspætʃər]又叫前置控制器、前端控制器、分发器
• 2.HandlerMapping是处理器映射器
• 3.HandlerExecutionChain是处理器执行链
• 4.HandlerAdapter是处理器适配器
• 5.Handler是处理器又叫后端处理器
• 6.ViewResolver视图解析器

二、get接口调用栈帧图

三、工作流程

• 1.看栈帧图，是咱最为熟悉的HttpServlet，前面是tomcat知识和一堆filter，后面是伟大springframework的内容
• 2.往下看走到了doGet方法，然后是DispatcherServlet的doService方法
• 3.下面对照着DispatcherServlet.java源码看（见源码部分）
• 4.doService方法中有个doDispatch(request, response)方法，doDispatch方法中便包含着整个DispatcherServlet的工作核心逻辑
• 5.HandlerExecutionChain mappedHandler = getHandler(processedRequest);根据用户的请求request得到一个处理器执行链，getHandler方法中有遍历处理器映射器集合（handlerMappings）的操作。
• 6.拿到处理器handler之后，再用处理器handler去拿HandlerAdapter处理器适配器HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());也是通过遍历处理器适配器列表拿的
• 7.然后处理器适配器用处理器执行handle处理方法，此方法会调用我们的业务方法 mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); 返回的参数是一个modelAndView
• 8.接下来开始渲染这个modelAndView，processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); 视图解析器渲染视图render(mv, request, response);也是遍历视图解析器列表，找到一个视图解析器，View view = viewResolver.resolveViewName(viewName, locale); 解析到一个view
• 9.view解析视图view.render(mv.getModelInternal(), request, response);

四、总结

• 1.用户发送请求到前置控制器DispatcherServlet (doDispatch(HttpServletRequest request, HttpServletResponse response))
• 2.前置控制器DispatcherServlet收到请求后，调用处理器映射器HandlerMapping，请求获取处理器Handler (mappedHandler = getHandler(processedRequest); )
• 3.处理器映射器HandlerMapping根据请求的url找到具体的处理器Handler，生成处理器对象和处理器拦截器（如果有则生成），返回给前置控制器DispatcherServlet (拦截器的内容在这里HandlerExecutionChain handler = mapping.getHandler(request); )
• 4.前置处理器DispatcherServlet调用处理器适配器HandlerAdapter (HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); )
• 5.处理器适配器HandlerAdapter经过适配后调用具体的处理器Handler(后端处理器)， 处理器Handler处理完返回一个ModelAndView， 处理器适配器HandlerAdapter将处理器Handler返回的ModelAndView返回给前置控制器DispatcherServlet（mv = ha.handle(processedRequest, response, mappedHandler.getHandler());）
• 6.前置控制器DispatcherServlet将ModelAndView传给视图解析器ViewResolver进行解析 （view = resolveViewName(viewName, mv.getModelInternal(), locale, request); ）
• 7.视图解析器ViewResolver解析后返回具体的视图View (View view = viewResolver.resolveViewName(viewName, locale); )
• 8.前置控制器DispatcherServlet对视图View进行渲染（将模型数据填充到视图View中）(view.render(mv.getModelInternal(), request, response); )
• 9. 前置控制器响应用户结束

五、流程图

六、源码

DispatcherServlet.java源码

/** Copyright 2002-2019 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**      https://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.Arrays;
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 java.util.stream.Collectors;import javax.servlet.DispatcherType;
import javax.servlet.ServletContext;
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.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.core.log.LogFormatUtils;
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;/*** 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.** 
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:** 
* 
It is based around a JavaBeans configuration mechanism.** 
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).** 
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).** 
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).** 
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).** 
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}.** 
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.** 
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}.** 
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}.* 
** 
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}.** 
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.** 
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.** @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}* 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 a* {@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. */@Nullableprivate MultipartResolver multipartResolver;/** LocaleResolver used by this servlet. */@Nullableprivate LocaleResolver localeResolver;/** ThemeResolver used by this servlet. */@Nullableprivate ThemeResolver themeResolver;/** List of HandlerMappings used by this servlet. */// 处理器映射器 列表@Nullableprivate List handlerMappings;/** List of HandlerAdapters used by this servlet. */@Nullableprivate List handlerAdapters;/** List of HandlerExceptionResolvers used by this servlet. */@Nullableprivate List handlerExceptionResolvers;/** RequestToViewNameTranslator used by this servlet. */@Nullableprivate RequestToViewNameTranslator viewNameTranslator;/** FlashMapManager used by this servlet. */@Nullableprivate FlashMapManager flashMapManager;/** List of ViewResolvers used by this servlet. */@Nullableprivate 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}.*/@Overrideprotected 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);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.isTraceEnabled()) {logger.trace("Detected " + this.multipartResolver);}else if (logger.isDebugEnabled()) {logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());}}catch (NoSuchBeanDefinitionException ex) {// Default is no multipart resolver.this.multipartResolver = null;if (logger.isTraceEnabled()) {logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared");}}}/*** 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.isTraceEnabled()) {logger.trace("Detected " + this.localeResolver);}else if (logger.isDebugEnabled()) {logger.debug("Detected " + this.localeResolver.getClass().getSimpleName());}}catch (NoSuchBeanDefinitionException ex) {// We need to use the default.this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);if (logger.isTraceEnabled()) {logger.trace("No LocaleResolver '" + LOCALE_RESOLVER_BEAN_NAME +"': using default [" + this.localeResolver.getClass().getSimpleName() + "]");}}}/*** 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.isTraceEnabled()) {logger.trace("Detected " + this.themeResolver);}else if (logger.isDebugEnabled()) {logger.debug("Detected " + this.themeResolver.getClass().getSimpleName());}}catch (NoSuchBeanDefinitionException ex) {// We need to use the default.this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);if (logger.isTraceEnabled()) {logger.trace("No ThemeResolver '" + THEME_RESOLVER_BEAN_NAME +"': using default [" + this.themeResolver.getClass().getSimpleName() + "]");}}}/*** 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 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.isTraceEnabled()) {logger.trace("No HandlerMappings declared for servlet '" + getServletName() +"': using default strategies from DispatcherServlet.properties");}}}/*** 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 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.isTraceEnabled()) {logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +"': using default strategies from DispatcherServlet.properties");}}}/*** 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 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.isTraceEnabled()) {logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +"': using default strategies from DispatcherServlet.properties");}}}/*** 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.isTraceEnabled()) {logger.trace("Detected " + this.viewNameTranslator.getClass().getSimpleName());}else if (logger.isDebugEnabled()) {logger.debug("Detected " + this.viewNameTranslator);}}catch (NoSuchBeanDefinitionException ex) {// We need to use the default.this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);if (logger.isTraceEnabled()) {logger.trace("No RequestToViewNameTranslator '" + REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME +"': using default [" + this.viewNameTranslator.getClass().getSimpleName() + "]");}}}/*** 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 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.isTraceEnabled()) {logger.trace("No ViewResolvers declared for servlet '" + getServletName() +"': using default strategies from DispatcherServlet.properties");}}}/*** 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.isTraceEnabled()) {logger.trace("Detected " + this.flashMapManager.getClass().getSimpleName());}else if (logger.isDebugEnabled()) {logger.debug("Detected " + this.flashMapManager);}}catch (NoSuchBeanDefinitionException ex) {// We need to use the default.this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);if (logger.isTraceEnabled()) {logger.trace("No FlashMapManager '" + FLASH_MAP_MANAGER_BEAN_NAME +"': using default [" + this.flashMapManager.getClass().getSimpleName() + "]");}}}/*** 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()*/@Nullablepublic 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)*/@Nullablepublic 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*/@Nullablepublic 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("Unresolvable class definition for DispatcherServlet's default strategy class [" +className + "] for interface [" + key + "]", 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.*/@Overrideprotected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {logRequest(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 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);}}}}private void logRequest(HttpServletRequest request) {LogFormatUtils.traceDebug(logger, traceOn -> {String params;if (StringUtils.startsWithIgnoreCase(request.getContentType(), "multipart/")) {params = "multipart";}else if (isEnableLoggingRequestDetails()) {params = request.getParameterMap().entrySet().stream().map(entry -> entry.getKey() + ":" + Arrays.toString(entry.getValue())).collect(Collectors.joining(", "));}else {params = (request.getParameterMap().isEmpty() ? "" : "masked");}String queryString = request.getQueryString();String queryClause = (StringUtils.hasLength(queryString) ? "?" + queryString : "");String dispatchType = (!request.getDispatcherType().equals(DispatcherType.REQUEST) ?"\"" + request.getDispatcherType().name() + "\" dispatch for " : "");String message = (dispatchType + request.getMethod() + " \"" + getRequestUri(request) +queryClause + "\", parameters={" + params + "}");if (traceOn) {List values = Collections.list(request.getHeaderNames());String headers = values.size() > 0 ? "masked" : "";if (isEnableLoggingRequestDetails()) {headers = values.stream().map(name -> name + ":" + Collections.list(request.getHeaders(name))).collect(Collectors.joining(", "));}return message + ", headers={" + headers + "} in DispatcherServlet '" + getServletName() + "'";}else {return message;}});}/*** 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*//*** 分发方法* 处理到处理程序的实际调度。* 处理程序将通过按顺序应用servlet的HandlerMappings来获得。* HandlerAdapter将通过查询servlet安装的HandlerAdapter来获得来查找第一个支持处理程序类的。* @param request* @param response* @throws Exception*/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 {processedRequest = checkMultipart(request);multipartRequestParsed = (processedRequest != request);// Determine handler for the current request.// 确定当前请求的处理程序。根据请求获取对应的handlermappedHandler = getHandler(processedRequest);if (mappedHandler == 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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {return;}}if (!mappedHandler.applyPreHandle(processedRequest, response)) {return;}// Actually invoke the handler.// 实际上调用处理程序, 处理器适配器调用处理器处理并返回一个modelAndViewmv = 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 afterCompletionif (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.*//*** 视图渲染，正常的和异常的* 处理处理程序选择和处理程序调用的结果，即一个ModelAndView或一个异常被解析为ModelAndView。* @param request* @param response* @param mappedHandler* @param mv* @param exception* @throws Exception*/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.isTraceEnabled()) {logger.trace("No view rendering, null ModelAndView returned.");}}if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {// Concurrent handling started during a forwardreturn;}if (mappedHandler != null) {// Exception (if any) is already handled..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*/@Overrideprotected 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) {if (request.getDispatcherType().equals(DispatcherType.REQUEST)) {logger.trace("Request already resolved to MultipartHttpServletRequest, e.g. by MultipartFilter");}}else if (hasMultipartException(request)) {logger.debug("Multipart resolution previously failed for current request - " +"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*//*** 为当前请求返回一个处理器执行链HandlerExecutionChain* @param request* @return* @throws Exception*/@Nullableprotected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {// 处理器映射器if (this.handlerMappings != null) {for (HandlerMapping mapping : this.handlerMappings) {HandlerExecutionChain handler = mapping.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 for " + request.getMethod() + " " + getRequestUri(request));}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.*//*** 根据处理器获取处理器适配器* @param handler* @return* @throws ServletException*/protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {if (this.handlerAdapters != null) {for (HandlerAdapter adapter : this.handlerAdapters) {if (adapter.supports(handler)) {return adapter;}}}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*/@Nullableprotected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,@Nullable Object handler, Exception ex) throws Exception {// Success and error responses may use different content typesrequest.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);// Check registered HandlerExceptionResolvers...ModelAndView exMv = null;if (this.handlerExceptionResolvers != null) {for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {exMv = resolver.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.isTraceEnabled()) {logger.trace("Using resolved error view: " + exMv, ex);}else if (logger.isDebugEnabled()) {logger.debug("Using resolved error view: " + exMv);}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*//*** 渲染视图* @param mv* @param request* @param response* @throws Exception*/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.isTraceEnabled()) {logger.trace("Rendering view [" + view + "] ");}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 + "]", 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*/@Nullableprotected 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*//*** 视图解析器解析视图* @param viewName* @param model* @param locale* @param request* @return* @throws Exception*/@Nullableprotected View resolveViewName(String viewName, @Nullable Map 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 removedattrsToCheck.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;}}