[置顶] 详解spring-MVC DispatcherServlet运行
HttpServletBean
HttpServletBean主要参与了创建工作，并没有涉及请求的处理。
FrameworkServlet
在FrameworkServlet中重写了service,doGet,doPost(除了doHead以外的所有请求处理方法)
#
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//得到是何种方法
String method = request.getMethod();
if(method.equalsIgnoreCase(RequestMethod.PATCH.name())) {
this.processRequest(request, response);
} else {
super.service(request, response);
}
}
protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}在这里跟HttpServlet不同，将不同类型的请求路由到不同方法进行处理的思路正好相反，这里又将所有的请求合并到了processRequest方法。
接下来看processRequest方法
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
long startTime = System.currentTimeMillis();
Object failureCause = null;
//获取LocaleContext
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
//获取当前请求的LocaleContext
LocaleContext localeContext = this.buildLocaleContext(request);
//获取RequestAttributes
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
//获取当前请求的ServletRequestAttributes
ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor(null));
//把当前请求的LocaleContext和ServletRequestAttributes设置到LocaleContextHolder和RequestContextHolder
this.initContextHolders(request, localeContext, requestAttributes);
try {
//实际处理
this.doService(request, response);
} catch (ServletException var17) {
failureCause = var17;
throw var17;
} catch (IOException var18) {
failureCause = var18;
throw var18;
} catch (Throwable var19) {
failureCause = var19;
throw new NestedServletException("Request processing failed", var19);
} finally {
//恢复原来的
this.resetContextHolders(request, previousLocaleContext, previousAttributes);
if(requestAttributes != null) {
requestAttributes.requestCompleted();
}
if(this.logger.isDebugEnabled()) {
if(failureCause != null) {
this.logger.debug("Could not complete request", (Throwable)failureCause);
} else if(asyncManager.isConcurrentHandlingStarted()) {
this.logger.debug("Leaving response open for concurrent processing");
} else {
this.logger.debug("Successfully completed request");
}
}
//发布了ServletRequestHanledEvent消息。
this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause);
}
}在这个方法之中doService是核心方法，在DispatcherServlet中具体实现。doService前后还做了写事情，装修者模式。主要是做了两件事：
1.对LocaleContext（本地消息）和RequestAttributes(属性获取用于管理request和session)的设置及恢复;
2.处理完后发布了ServletRequestHandledEvent消息。
DispatcherServlet
经过上面的分析我们的代码在doService()中，接下来分析
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
if(this.logger.isDebugEnabled()) {
String attributesSnapshot = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult()?" resumed":"";
this.logger.debug("DispatcherServlet with name \'" + this.getServletName() + "\'" + attributesSnapshot + " processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
}
HashMap attributesSnapshot1 = null;
if(WebUtils.isIncludeRequest(request)) {
attributesSnapshot1 = new HashMap();
Enumeration inputFlashMap = request.getAttributeNames();
while(inputFlashMap.hasMoreElements()) {
String attrName = (String)inputFlashMap.nextElement();
if(this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
attributesSnapshot1.put(attrName, request.getAttribute(attrName));
}
}
}
//对request设置属性
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext());
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource());
FlashMap inputFlashMap1 = this.flashMapManager.retrieveAndUpdate(request, response);
if(inputFlashMap1 != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap1));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
try {
//真正执行的地方
this.doDispatch(request, response);
} finally {
if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot1 != null) {
this.restoreAttributesAfterInclude(request, attributesSnapshot1);
}
}
}我们首先会设置webApplicationContext,localResolver,themeResolver和themeSource在之后介绍的handler和view中需要使用，到时候再作分析。后面三个属性都和flashMap有关，主要是用于重定向的参数和传递。一般我们重定向的时候传参数过去只有靠url的重写，但是这里我们可以使用flushMap向其中传递我们需要传递的参数然后就可以进行重定向的传参了。
接下来对doDispatch进行分析
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
try {
ModelAndView err = null;
Exception dispatchException = null;
try {
processedRequest = this.checkMultipart(request);
multipartRequestParsed = processedRequest != request;
mappedHandler = this.getHandler(processedRequest);
if(mappedHandler == null || mappedHandler.getHandler() == null) {
this.noHandlerFound(processedRequest, response);
return;
}
HandlerAdapter ex = this.getHandlerAdapter(mappedHandler.getHandler());
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if(isGet || "HEAD".equals(method)) {
long lastModified = ex.getLastModified(request, mappedHandler.getHandler());
if(this.logger.isDebugEnabled()) {
this.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;
}
err = ex.handle(processedRequest, response, mappedHandler.getHandler());
if(asyncManager.isConcurrentHandlingStarted()) {
return;
}
this.applyDefaultViewName(request, err);
mappedHandler.applyPostHandle(processedRequest, response, err);
} catch (Exception var19) {
dispatchException = var19;
}
this.processDispatchResult(processedRequest, response, mappedHandler, err, dispatchException);
} catch (Exception var20) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, var20);
} catch (Error var21) {
this.triggerAfterCompletionWithError(processedRequest, response, mappedHandler, var21);
}
} finally {
if(asyncManager.isConcurrentHandlingStarted()) {
if(mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
} else if(multipartRequestParsed) {
this.cleanupMultipart(processedRequest);
}
}
}上面是大概的代码其实把所有代码精简了之后缩略为4句：
1.mappedHandler = this.getHandler(processedRequest);
2.HandlerAdapter ex = this.getHandlerAdapter(mappedHandler.getHandler());
3.err = ex.handle(processedRequest, response, mappedHandler.getHandler());
4.this.processDispatchResult(processedRequest, response, mappedHandler, err, dispatchException);
上面4句话概括为:
1.根据request找到Handler。
2.根据Handler找到对应的HandlerAdapter
3.用HandlerAdapter处理Handler
4.调用processDispatchResult处理方法结果。
这里需要解释三个概念：HandlerMapping,Handler和HandlerAdapter。
Handler:也就是处理器，它直接对应着MVC中的C层也就是controller层，它的具体表现形式有很多，可以是类，也可以是方法，如果你能想到别的表现形式也可以使用。类型是Object。对于注解中我们只要标注了@RequestMapping的所有方法都可以看成一个Handler。只要可以处理实际请求就可以是Handler。
HandlerMapping:用来查找Handler的，在Spring MVC中会处理很多请求，每个请求都需要一个Handler处理，我们接收到请求以后使用哪个Handler来处理呢？这就是HandlerMapping需要来告诉我的。
HandlerAdapter:很多人对这个理解都比较模糊，其实从名字上可以看出他是一个Adapter，也就是适配器。因为Spring MVC中的Handler可以是任意形式，只要能处理请求就OK，但是Servlet需要的处理方法的结构是固定的，都是以request和response为参数，这个时候就需要一个适配器来处理这个Handler。
doDispatch总共可以分成4句话，我们也可以把它分为两部分：处理请求和渲染页面。
在整个程序流程开始的时候我们会有如下的定义
//请求,如果不是上传请求则直接使用接收到的request，否则进行处理
HttpServletRequest processedRequest = request;
//处理请求链，包含我们的拦截器和我们处理器。
HandlerExecutionChain mappedHandler = null;
//上传文件标志位
boolean multipartRequestParsed = false;
//封装Model和View
ModelAndView err = null;
//处理请求过程中抛出的异常
Exception dispatchException = null;具体步骤
1。doDispatch中首先检查是不是上传请求判断是否是Post并且content-Type是否以”multipart/”开头,如果是则会进行处理。会把文件和对应的名字封装成map。
2。通过getHandler方法获取Handler处理器链，原理是使用HandlerMapping。举一个例子来说：对于我们的方法处理器Mapping来说 会通过我们的AbstractHandlerMethodMapping首先通过我们的URL找到了我们的匹配条件，然后根据我们的匹配条件这里的匹配条件不止是URL匹配这么简单也包括我们get,post方法请求和请求参数等。利用匹配条件找到了Handler。
3。然后使用HandlerAdapter适配器处理我们的请求。
4。处理异常，渲染页面。