SpringMVC 执行流程（深入源码）

1. 简介

       相信SpringMVC处理请求的流程各位滚瓜烂熟了都，如下图所示。

       但是如果没有读过代码，还是有很多问题，如Request如何被接收到，ModelAndView是否可以为空，项目中我们通常返回一串json给前端，是怎么处理的？

2. 深入源码

2.1 Debug

/**
 * @author wangzhao
 * @date 2020/8/12 23:07
 */
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String sayHello(HttpServletRequest req, HttpServletResponse resp) {
        return "Hello World";
    }

}

       首先的话，我们打断点，分析其调用栈。

       直接进入到service方法，之前的代码并不需要关心。

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request;
        HttpServletResponse response;
        try {
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }

        this.service(request, response);
    }

       该方法位于HttpServlet中，这不就和我们一开始用HttpServlet写的代码一样吗，请求直接进入到了HttpServlet#service方法中。

       一直向下进行调用，最后到了org.springframework.web.servlet.DispatcherServlet#doDispatch。

       至此，请求才算正式进入到MVC 请求的处理流程中，相信你也一定知道请求是如何被DispatcherServlet所接受到。

2.2 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) {
					// 找不到handler报错 
					noHandlerFound(processedRequest, response);
					return;
				}

				// 获取处理器适配器
				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;
				}

				// 执行handler
				mv = 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 afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

2.2.1 getHandler(processedRequest)

       获取请求对应的Handler，可以看到，已经成功获取到目标Handler。

	protected 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;
	}

2.2.2 getHandlerAdapter(mappedHandler.getHandler())

       获取Handler对应的适配器。

	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");
	}

2.2.3 handle(HttpServletRequest request, HttpServletResponse response, Object handler)

       执行handle，返回ModelAndView。

       可以看到，返回的ModelAndView是null，这样的逻辑也是符合我们的代码的，我们并没有在sayHello中返回ModelAndView。

       那如果我们直接返回json格式的数据，那么该数据哪里去了？答案是已经被封装到了response中，查找了一番没有找到，该对象属性太多，最后只找到了json的长度为11字节，所以可知其也一定被封装到里卖弄。

       这一下是不是已经解决了我们开始提问的两个问题？

2.2.4 applyPostHandle(processedRequest, response, mv)

       视图解析。

       进入该方法后，直接跟踪到如下方法。

	// org.springframework.web.servlet.handler.WebRequestHandlerInterceptorAdapter#postHandle
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {

		this.requestInterceptor.postHandle(new DispatcherServletWebRequest(request, response),
				(modelAndView != null && !modelAndView.wasCleared() ? modelAndView.getModelMap() : null));
	}

       在这里做的就是将ModelAndView中的数据填充到View中，最后通过Response展示给用户，如下便完成了一个MVC的请求流程。

3. 总结

       通过此次代码分析，相信之前很多不懂或模糊的地方可以豁然开朗。

       Talk is cheap. Show me the code.