SpringMVC工作原理及DispatcherServlet源码解析

一、SpringMVC整体流程

先来看看SpringMVC的工作流程图：

下面来看看每一步都是在做什么：

第一步：用户发起request请求，请求至DispatcherServlet前端控制器。

第二步：DispatcherServlet前端控制器请求HandlerMapping处理器映射器查找Handler。

              DispatcherServlet：前端控制器，相当于中央调度器，各各组件都和前端控制器进行交互，降低了各组件之间耦合度。

第三步：HandlerMapping处理器映射器，根据url及一些配置规则（xml配置、注解配置）查找Handler，将Handler返回给                          DispatcherServlet前端控制器。

第四步：DispatcherServlet前端控制器调用适配器执行Handler，有了适配器通过适配器去扩展对不同Handler执行方式（比如：                原始servlet开发，注解开发）

第五步：适配器执行Handler。Handler是后端控制器，当成模型。

第六步：Handler执行完成返回ModelAndView

              ModelAndView是springmvc的一个对象，对Model和view进行封装。

第七步：适配器将ModelAndView返回给DispatcherServlet

第八步：DispatcherServlet调用视图解析器进行视图解析，解析后生成view。视图解析器根据逻辑视图名解析出真正的视图。

              View：springmvc视图封装对象，提供了很多view，比如：jsp、freemarker、pdf、excel。

第九步：ViewResolver视图解析器给前端控制器返回view

第十步：DispatcherServlet调用view的渲染视图的方法，将模型数据填充到request域 。

第十一步：DispatcherServlet向用户响应结果(jsp页面、json数据。)

在这里面有几个组件要说一下：

• DispatcherServlet：前端控制器，由springmvc提供
• HandlerMappting：处理器映射器，由springmvc提供
• HandlerAdapter：处理器适配器，由springmvc提供
• Handler：处理器，需要程序员开发
• ViewResolver：视图解析器，由springmvc提供
• View：真正视图页面需要由程序编写

 由上面springMVC的工作流程图我们可以知道，其实springMVC的核心就是DispatcherServlet，所以接下来主要就是通过源码来看看DispatcherServlet是怎么工作的。

FROM 《SpringMVC - 运行流程图及原理分析》

流程示意图：

代码序列图：

---

FROM 《看透 Spring MVC：源代码分析与实践》 P123

流程示意图：

 

二、服务流程

一般而言，Servlet有一个服务方法 doService来为HTTP请求提供服务(如参照前面的servlet源码解析)， DispatcherServlet也是如此，它的 doService 方法如下面代码所示：

//将DispatcherServlet特定的请求转发给doDispatch处理
@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) + "]");
	}
	// 快照处理，使用快照可以更快响应用户请求
	Map<String, Object> attributesSnapshot = null;
	if (WebUtils.isIncludeRequest(request)) {
		attributesSnapshot = new HashMap<String, Object>();
		Enumeration<?> attrNames = request.getAttributeNames();
		while (attrNames.hasMoreElements()) {
			String attrName = (String) attrNames.nextElement();
			if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
				attributesSnapshot.put(attrName, request.getAttribute(attrName));
			}
		}
	}
	// 设置Web IOC容器
	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());
	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);
			}
		}
	}
}

由上面的代码和注释可以看到，doService先对HTTP请求进行一些处理，然后设置一些属性，最后所有的流程都集中在了 doDispatch 方法中。所以接下来我们继续看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 {
            //模型和视图
			ModelAndView mv = null;
            //错误处理
			Exception dispatchException = null;
			try {
                //文件上传处理解析器
				processedRequest = checkMultipart(request);
                //是否为文件上传请求
				multipartRequestParsed = (processedRequest != request);
				// 获得匹配的执行链，决定处理请求的handler
				mappedHandler = getHandler(processedRequest);
                //没有处理器错误
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// 找到对应的处理器适配器(HandlerAdapter)
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
                ///判断是 http 的 get 方法还是 post 方法或其他
				String method = request.getMethod();
                //如果是GET方法的处理
				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;
					}
				}
                //执行拦截器的事前方法，如果返回 false，则流程结束
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
                //执行处理器，返回 ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
                //如果视图为空，给予设置默认视图的名称
				applyDefaultViewName(processedRequest, mv);
                //执行处理器拦截器的事后方法
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
                //记录异常
				dispatchException = ex;
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Throwable ex) {
            //记录异常
			 dispatchException = new NestedServletException(”Handler dispatch failed ”, err) ;
		}
        //处理请求结果，显然这里已经通过处理器得到最后的结果和视图 
        //如果是逻辑视图，则解析名称，否则就不解析，最后渲染视图
            processDispatchResult(processedRequest, response,mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            //异常处理，拦截器完成方法
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
            //错误处理
			triggerAfterCompletionWithError(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);
				}
			}
		}
	}

通过源码可以看出其流程是 :
(l)通过请求找到对应的执行链，执行链包含了拦截器和开发者控制器。

(2)通过处理器找到对应的适配器。

(3)执行拦截器的事前方法，如果返回 false，则流程结束，不再处理 。

(4)通过适配器运行处理器，然后返回模型和视图。

(5)如果视图没有名称 ，则 给出默认的视图名称。

(6)执行拦截器的事后方法。

(7)处理分发请求得到的数据模型和视图的渲染。

三、处理器和执行器

在上面，我们已经了解了一个请求到达springMVC后，DispatcherServlet是怎么处理这个请求的，接下来就是看看处理器和拦截器，即DispatcherServlet的getHandler方法：

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) {
				return handler;
			}
		}
		return null;
	}

在启动期间， SpringMVC已经初始化了处理器映射--HandlerMappings，所以这里先根据请求找到对应的 HandlerMapping，找到 HandlerMapping 后，就把相关处理的内容转化成一个 HandlerExecutionChain 对象。

接下来就来看看HandlerExecutionChain的结构是什么样的：

public class HandlerExecutionChain {

	private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
    //处理器，自己写的控制器(或其方法)
	private final Object handler;
    //拦截器数组
	private HandlerInterceptor[] interceptors;
    //拦截器列表
	private List<HandlerInterceptor> interceptorList;
    //当前拦截器下标，当使用数组时有效
	private int interceptorIndex = -1;
    ...
}

由源码可以看出，主要是定义一些拦截器相关的属性，可以在进入控制器之前 ， 运行对应的拦截器，这样就可以在进入处理器前做一些逻辑了。如果在做电商系统的时候，用户可以再未登录状态浏览商品，并加入购物车，但是如果要结算的时候，这个时候就要拦截请求，要求用户登录。这个时候就可以通过拦截器实现。接下来就来看看拦截器Handlerlnterceptor的相关方法：

public interface HandlerInterceptor {
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
	    throws Exception;
    void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception;
    void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception;

依据 doDispatch 方法，当preHandle方法返回为 true 的时候才会继续运行，否则就会结束流程，而在数据模型渲染视图之前调用 postHandle方法， 在流程的 finally语 句中还会调用 afterCompletion方法， 这就是处理器拦截器的内容。如果要自己做一个拦截器的话，可以实现Handlerlnterceptor接口，然后重写这三个方法，你可以在这三个方法里面加入相应的业务逻辑进行处理。

四、视图渲染

在第二点的时候，我们知道processDispatchResult对模型和视图的处理，接下来我们来看看SpringMVC是怎么实现视图渲染。

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			HandlerExecutionChain mappedHandler, ModelAndView mv, 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);
			}
		}

		//处理器是否返回视图和模型
		if (mv != null && !mv.wasCleared()) {
            //渲染视图
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
		else {
            //视图为 null，或者已经被处理过
			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);
		}
	}

由上面的源码可以看出，首先是先判断是否异常，如果有异常就再进一步处理是什么异常，如果没有异常就通过render方法进行进一步处理，相关逻辑也在注释中表明了，接下来就来看看render这个方法：

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.resolveLocale(request);
		response.setLocale(locale);
		View view;
//是否是逻辑视图，如果是需要转化为真实路径下的视图
		if (mv.isReference()) {
			// We need to resolve the view name.
//转化逻辑视图为真实视图
			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
			if (view == null) {
				throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
						"' in servlet with name '" + getServletName() + "'");
			}
		}
//非逻辑视图
		else {
			// No need to lookup: the ModelAndView object contains the actual View object.
			view = mv.getView();
			if (view == null) {
				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
						"View object in servlet with name '" + getServletName() + "'");
			}
		}

		// Delegate to the View object for rendering.
		if (logger.isDebugEnabled()) {
			logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
		}
		try {
//渲染视图， view 为视圈， mv.getModelInternal ()为数据模型
			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;
		}
	}

首先是国际化的设置，然后判断是否是逻辑视图，如果是就转化它为 真实视图，或者 直接获取视图即可，最后进入视图的 render方法，将模型和视图中的数据模型传递到该方 法中去，这样就完成了视图的渲染，展示给用户。