DispatcherServlet的doDispatch方法主要用作职责调度工作，本身主要用于控制流程，主要职责如下：
1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
4、调用HandlerExecutionChain的interceptor和handler
5、解析视图、处理异常，渲染具体的视图等；
1. 1：doDispatch方法中：如下：
/**
* Process the actual dispatching to the handler. //处理实际调度处理器
* <p>The handler will be obtained by applying the servlet's HandlerMappings in order. //处理程序将通过按顺序的servlet的处理器映射器获得。
* The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters //处理器适配器将通过查询servlet的安装的处理器适配器来获得
* to find the first that supports the handler class. //找到支持处理程序类的第一个。
* <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers //所有HTTP方法都由此方法处理。 这取决于处理器适配器或处理程序
* themselves to decide which methods are acceptable. //自己决定哪些方法是可以接受的。
* @param request current HTTP request //请求当前HTTP请求
* @param response current HTTP response //响应当前的HTTP响应
* @throws Exception in case of any kind of processing failure //任何类型的处理失败的例外
*/
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request; //processedRequest是经过checkMultipart方法处理过的request请求
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false; WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); try {
ModelAndView mv = null;
Exception dispatchException = null; try {
//1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
//2.通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
// Determine handler for the current request. 确定当前请求的处理程序。
mappedHandler = getHandler(processedRequest); //解析第一个方法
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
//3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
// 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(); //得到当前的http方法。
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) { //处理http的head方法。这种方法应该很少用
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;
}
}
//4.1调用HandlerExecutionChain的interceptor
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
//4.2执行解析handler中的args，调用（invoke） controller的方法。得到视图
// Actually invoke the handler. 实际上调用处理程序。
mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); //解析第三个方法 if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//4.3调用HandlerExecutionChain的interceptor
applyDefaultViewName(processedRequest, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
//5.解析视图、处理异常
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Error err) {
triggerAfterCompletionWithError(processedRequest, response, mappedHandler, 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);
}
}
}
}
1.2： DispatcherServlet类中 找到 getHandler
/**
* Return the HandlerExecutionChain for this request. //返回该请求的处理程序执行链
* <p>Tries all handler mappings in order. //尝试按顺序处理所有的处理程序映射。
* @param request current HTTP request //请求当前HTTP请求
* @return the HandlerExecutionChain, or {@code null} if no handler could be found //处理程序执行链或代码返回null，如果没有找到处理程序
*/
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
}
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
//只会调用一个handler进行处理
return handler;
}
}
return null;
}
1.3：我们转而去找HandlerMapping的getHander()发现HandlerMapping是一个接口，找到了实现类
/**
* Look up a handler for the given request, falling back to the default //查找给定请求的处理程序，回到默认值
* handler if no specific one is found. //处理程序，如果没有找到特定的。
* @param request current HTTP request //请求当前HTTP请求
* @return the corresponding handler instance, or the default handler //相应的处理程序实例或默认处理程序
* @see #getHandlerInternal //得到内部处理程序
*/
@Override
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//从实现类中获得处理方法
Object handler = getHandlerInternal(request);
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
// Bean name or resolved handler? //Bean名称或解决的处理程序？
if (handler instanceof String) {
String handlerName = (String) handler;
handler = getApplicationContext().getBean(handlerName);
}
//获得处理程序执行链
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (CorsUtils.isCorsRequest(request)) {
CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}
1.4:
/**
* Build a {@link HandlerExecutionChain} for the given handler, including //为给定的处理程序构建一个链接处理程序执行链，包括
* applicable interceptors. //适用拦截器。
* <p>The default implementation builds a standard {@link HandlerExecutionChain} //默认实现构建一个标准的链接处理程序执行链
* with the given handler, the handler mapping's common interceptors, and any //与给定的处理程序，处理程序映射的常见拦截器和任何
* {@link MappedInterceptor}s matching to the current request URL. Interceptors //映射映射拦截器与当前请求URL匹配。拦截器
* are added in the order they were registered. Subclasses may override this //按照注册顺序添加。 子类可以覆盖此
* in order to extend/rearrange the list of interceptors. //以便扩展/重新排列拦截器列表。
* <p><b>NOTE:</b> The passed-in handler object may be a raw handler or a //注意：传入处理程序对象可能是原始处理程序或
* pre-built {@link HandlerExecutionChain}. This method should handle those //预制链接处理程序执行链。 这种方法应该处理那些
* two cases explicitly, either building a new {@link HandlerExecutionChain} //建立一个新的链接处理程序执行链
* or extending the existing chain. //或扩展现有的链。
* <p>For simply adding an interceptor in a custom subclass, consider calling //为了简单地在自定义子类中添加拦截器，请考虑调用
* {@code super.getHandlerExecutionChain(handler, request)} and invoking //代码:得到父类处理程序执行链（处理器，请求）}并调用
* {@link HandlerExecutionChain#addInterceptor} on the returned chain object. //{@链接处理程序执行链、添加拦截器}在返回的链对象上。
* @param handler the resolved handler instance (never {@code null}) //处理程序解析的处理程序实例（代码从不为空）
* @param request current HTTP request //请求当前HTTP请求
* @return the HandlerExecutionChain (never {@code null}) //处理程序执行链（代码从不为空）
* @see #getAdaptedInterceptors() //获得适应的拦截器
*/
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
//如果没有获得则创建一个
HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
//获得IP地址及端口后的URL地址
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
//在HandlerExecutionChain中添加拦截器
// 遍历 SpringMVC 容器的所有拦截器
for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
// 判断拦截器类型，属于 MappedInterceptor，则先匹配路径，否则直接添加
if (interceptor instanceof MappedInterceptor) {
MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
//根据lookupPath来获取Interceptor
if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
chain.addInterceptor(mappedInterceptor.getInterceptor());
}
}
else {
chain.addInterceptor(interceptor);
}
}
return chain;
}
结论：处理器执行链=1个hanlder+N个Interceptor
2.1:HandlerAdaptor执行流程（进入方法在1.1）
/**
* 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.
*/ //抛出的异常：如果找不到处理程序适配器，则Servlet异常。这是一个致命错误。
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
//遍历所有的handlerAdapters
for (HandlerAdapter ha : this.handlerAdapters) {
if (logger.isTraceEnabled()) {
logger.trace("Testing handler adapter [" + ha + "]");
}
//调用相应实现的support方法，排在最前面的优先调用
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");
}
3.1:在这里发现了一个接口，找到它 的实现（进入方法在1.1）
/**
* Use the given handler to handle this request. //使用给定的处理程序来处理此请求。
* The workflow that is required may vary widely. //所需的工作流程可能会有很大差异。
* @param request current HTTP request //请求当前HTTP请求
* @param response current HTTP response //响应当前的HTTP响应
* @param handler handler to use. This object must have previously been passed //处理程序处理程序使用 此对象必须先前已被传递
* to the {@code supports} method of this interface, which must have //到这个接口的{@code支持}方法，它必须具有
* returned {@code true}. //已返回{@code true}。
* @throws Exception in case of errors //异常情况下出错
* @return ModelAndView object with the name of the view and the required //ModelAndView对象具有视图的名称和必需
* model data, or {@code null} if the request has been handled directly //模型数据，或{@code null}，如果请求已被直接处理
*/
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
3.2接口的各个实现
3.3这里我们用的是SimpleControllerHandlerAdapter
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
//判断是否是Controller类
return (handler instanceof Controller);
}
//执行Controller的handleRequest方法
@Override
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
//本质是执行Controller的handleRequest方法
return ((Controller) handler).handleRequest(request, response);
}
@Override
public long getLastModified(HttpServletRequest request, Object handler) {
if (handler instanceof LastModified) {
return ((LastModified) handler).getLastModified(request);
}
return -1L;
}
}