SpringMVC DispatcherServlet 源码分析

已知， DispatcherServlet这个类是 spring 用于处理请求的。
我们先来看看 它的 继承关系：

可以发现，它是从 Servlet规范来的，还继承了 HttpServlet这个类，我们犹记得 javaweb中 我们就是继承 HttpServlet这个类，重写 doGet()和 doPost()方法来达到请求的处理的。
既然如此，它的继承关系中，肯定有一个类也是重写了 doGet() 和 doPost 方法，经查，是 FrameworkServlet 这个类

调用的是 processRequest(request, response); 这个方法来处理

在该方法中，在一堆属性设置之后，又调用了 doService(request, response);这个方法来处理，再去找：

发现，该方法让子类去实现了，而 FrameworkServlet 又只有 DispatcherServlet这一个子类，所以进入子类的 doService:

在该方法中，又是一堆 setAttribute() 方法，我们直接忽略，看到一个

doDispatch(request, response);

方法，具体的操作应该就在这个方法里面了！！！

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.
				mappedHandler = 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 = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(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.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

				applyDefaultViewName(processedRequest, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	//catch 及 finally 块
	}

该代码我将 catch 和 finally块去掉了。

第一步，定义了一个 HandlerExecutionChain 对象，我们看一下这个类：

注意一下 handler和 interceptorList这两个变量，直接看英文也可以猜出来 前者是 处理器 ，后者是 拦截器
接下来看到这一行：

这里是使用 getHandler 给 HandlerExecutionChain 对象赋值，进入该方法：

可以看到遍历 一个HandlerMapping的集合，只要得到了 HandlerExecutionChain 对象就退出。
所以我么查看 getHandler()方法，发现是一个接口，我们不确定调用的是哪一个实现类重写的方法，所以debug一下：

发现走的是 AbstractHandlerMapping 这个实现类重写的方法，所以来看一下具体做的操作：
如上图，我们看到第一句就是 调用 getHandlerInternal()方法来获取 handler 处理器。点进去看时发现是抽象方法，所以又需要 debug来看一下具体调用的是哪个重写的方法，发现是 RequestMappingInfoHandlerMapping类重写的，

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
		try {
			return super.getHandlerInternal(request);
		}
		finally {
			ProducesRequestCondition.clearMediaTypesAttribute(request);
		}
	}

可以看到，将操作交给了getHandlerInternal() 方法：

/**
	 * Look up a handler method for the given request.
	 */
	protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		String lookupPath = initLookupPath(request);
		this.mappingRegistry.acquireReadLock();
		try {
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
			this.mappingRegistry.releaseReadLock();
		}
	}

如上，看一下注释，说的是 为这个请求寻找一个处理器方法。这里就不往下分析了，往下分析过于复杂，我们只需要知道 该方法是从我们所写的 Controller里面寻找一个 和当前 url 对应的那个方法来处理当前请求。

Object handler = getHandlerInternal(request);

执行过之后，我们就得到了具体的Controller的那一个方法来执行当前的请求

往下走，

	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

看到该方法返回的是我们在外层需要的HandlerExecutionChain对象，所以该方法需要重点关注一下：

	protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				if (mappedInterceptor.matches(request)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

第一步根据handler的类型决定如何创建HandlerExecutionChain对象，handler的类型应该是 HandlerMethod，所以使用构造方法创建对象，

将handler 处理器封装到了 HandlerExecutionChain对象里。
后面的循环：

for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				if (mappedInterceptor.matches(request)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}

很容易理解，就是将能对当前url进行拦截的拦截器添加到 HandlerExecutionChain对象里面去。

上面两步完成了，一个 完整的HandlerExecutionChain对象就封装好了，
然后回到 DispatcherServlet类的 getHandler()方法。，判断完非空之后，就回到了 doDispatch()方法：

下一步执行的就是 getHandlerAdapter() 的方法，参数是 某个Controller的那个方法，类型是 HandlerMethod

/**
	 * 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 adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
	}

很容易理解，就是找到一个能支持 handler的 Adpter来执行 handler。

这里其实用到了适配器模式，必须要知道，HandlerExecutionChain对象中的处理器handler 不止 Controller一种类型，可以用于Web请求处理的统称为Handler，Controller只是Handler的一种特殊类型。如果不使用适配器模式，那么就只能用 if-else例举出每一种可能的Handler类型，这是不具有扩展性的，为了能够以统一的方式调用各种类型的Handler， DispatcherServlet将不同的Handler调用职责交给了 HandlerAdapter

所以，如果我们是Controller作为handler，最后得到的 HandlerAdapter 应该是 SimpleControllerHandlerAdapter


如图，和我们的猜想一样，使用 supports()方法来判断是否是Controller类型，用handle() 去具体执行请求。

现在得到了 HandlerAdapter对象
回到 doDispatch() 方法

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

我们再去看看HandlerExecutionChain类里的这个方法：

可以发现，是执行每一个拦截器的 preHandle()方法

回到 doDispatch() 方法，下一步是

// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

根据注释，我们都知道是执行我们定义的 Controller里的逻辑，然后返回的是 ModelAndView对象

下一步：

applyDefaultViewName(processedRequest, mv);

这一步是给 ModelAndView对象设置视图名字

下一步：

mappedHandler.applyPostHandle(processedRequest, response, mv);

进入该方法查看一下：

可以发现，就是执行每一个拦截器的postHandle()方法，然后该方法有参数ModelAndView对象，可知在方法中可以对最后的模型视图对象修改，添加一些公共数据等等

回到 doDispatch() 方法，后面就是：

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

查看一下该方法：

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {
			
		// 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 (mappedHandler != null) {
			// Exception (if any) is already handled..
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

第一步是判断是否要渲染一个视图， 第二个继续查看该方法：

可以发现，第二个是执行所有拦截器的afterCompletion() 方法

总结：

Java要处理 Web请求，要继承 HttpServlet类并重写 doGet()和 doPost()方法
这一点在spring中仍然没有变化。 DispatcherServlet 重写doGet()的逻辑在 doDispatch()方法中，
在该方法中，定义了一个 HandlerExecutionChain对象来封装对 执行该请求的具体的处理器（就是我们编写的Controller里的具体方法）和能拦截该请求的所有拦截器，处理器和拦截器从Spring容器里找。
HandlerExecutionChain对象封装完毕之后，先执行 所有拦截器的 preHandle()方法，然后执行 Controller的具体逻辑，获得 ModelAndView对象，然后执行 所有拦截器的 postHandle()方法 ，然后如果 ModelAndView对象非NULL，那就渲染视图， 最后执行所有拦截器的 afterCompletion()收尾