Spring MVC请求执行全流程核心源码解析

Spring MVC框架基本是Java服务中不可缺少的功能，很多时候我们只知道如何使用，并不清楚如何解析请求的，如何实现Restful、如何返回结果甚至渲染页面的。本文就从源码讲解DispatcherServlet如何帮助我们解析客户端发起的请求。

本文结合SpringBoot讲解，先引用一张架构图，先大致知道每个组件的作用，后续再一一剖析。

1.DispatchServlet

处理请求的核心类

1.引入容器

我们先查看SpringBoot自动装配类，确定是否会在容器中引入，同时了解一下除了核心类外还有什么被引入到容器中，我们打开spring-boot-autoconfigure-2.3.7.RELEASE.jar包的spring.factories文件可以看到DispatcherServletAutoConfiguration配置类会被自动装配进我们容器中。

2.定位具体方法处

这个时候我们肯定还是不清楚，DispatcherServlet调用了哪个方法进行处理，我们可以搜索do开头的非私有方法，可以看到有两个
doService和doDispatch，不知道哪个没关系，可以在两个方法打个断点，然后给当前应用发起个请求，看看最终会进入到哪个方法中。

根据debug结果，我们可以发现两个方法都会执行，先执行doService后执行doDispatch。

那么我们可以确定doDispatch就是具体请求解析和执行的位置。

3.doDispatch

1.为当前请求选择合适的处理器（即Controller）

HandlerExecutionChain mappedHandler = null;
// 省略...
mappedHandler = getHandler(processedRequest);

进入该方法，可以发现我们会有很多个处理器选择器（HandlerMapping），会根据具体的请求选择是否有匹配的handler。

	// 初始化时候会从容器中获取，获取不到会设置默认的handlermapping
	@Nullable
	private List<HandlerMapping> handlerMappings;

	/**
	 * Return the HandlerExecutionChain for this request.
	 * 
Tries all handler mappings in order.
	 * @param request current HTTP request
	 * @return the HandlerExecutionChain, or {@code null} if no handler could be found
	 */
	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				// 如果能选择到合适的handlermapping
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

接着我们进入到getHandler中看看是如何选择合适的handler的，我们会发现getHandler这个方法，只在抽象类做了统一实现，所以我们定位到AbstractHandlermapping::getHandler中

	/**
	 * 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
	 * @return the corresponding handler instance, or the default handler
	 * @see #getHandlerInternal
	 */
	@Override
	@Nullable
	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		// 核心方法，用于选择handler
		Object handler = getHandlerInternal(request);
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}

		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

		if (logger.isTraceEnabled()) {
			logger.trace("Mapped to " + handler);
		}
		else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
			logger.debug("Mapped to " + executionChain.getHandler());
		}

		if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
			CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			config = (config != null ? config.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}

		return executionChain;
	}

我们继续进入到核心方法getHandlerInternal(request)中。发现最后都会调用到AbstractHandlerMethodMapping::getHandlerInternal中

	/**
	 * 根据request寻找合适的handler
	 */
	@Override
	protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		request.setAttribute(LOOKUP_PATH, lookupPath);
		this.mappingRegistry.acquireReadLock();
		try {
			// 核心方法用于获取handlermethod返回
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
			this.mappingRegistry.releaseReadLock();
		}
	}

我们进入核心方法中可以看到它调用了内部mappingRegistry来进行查找。而不同的handlermapping实现类，内部的MappingRegistry都是不同的对象。

所以可以从源码看出来，最终就是通过MappingRegistry来找到恰当的HandlerMethod（Controller）。
而最后它会封装成HandlerExecutionChain返回给DispatchServlet。
本质是把handler、interceptors一起封装进行返回。

2.MappingRegistry如何将Controller注册的？

上节说到，最终我们会根据MappingRegistry来进行handler方法的查找，那么这个mapping映射是怎么注册的呢？

我们观察MappingRegistry这个类，它是在AbstractHandlerMethodMapping中的内部类，我们观察有没有什么方法是往这个集合添加元素的。

我们看到内部有个方法register，比较像是注册的类，这个时候我们可以给个断点，运行后印证一下自己想法。

最终我们定位到AbstractHandlerMethodMapping的afterPropertiesSet方法。
最后恍然大悟，原来是创建bean的时候，回调了初始化方法来注册所有的handler。

3.拦截器调用

我们实现的拦截器就是在此处调用的，方法处理前，处理后，完成结果封装

4.具体Controller执行

前面说了具体执行方法封装成了HandlerMethod，但是因为HandlerMethod类型不统一，所以为了能够统一的执行，封装了一层HandleAdpater适配器，不同适配器处理不同类型的HandlerMethod

	HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
	// 不同的HandlerMethod选择对应的适配器来执行。
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
	
	}

最后关键执行方法。

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


	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	
		return handleInternal(request, response, (HandlerMethod) handler);
	}

进入到handleInternal中

@Override
	protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ModelAndView mav;
		checkRequest(request);

		// Execute invokeHandlerMethod in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// No HttpSession available -> no mutex necessary
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// 执行处理方法
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}

		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}

进入到invokeHandlerMethod中，可以发现核心方法

invocableMethod.invokeAndHandle(webRequest, mavContainer);

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		// 调用反射执行请求，获取返回值
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		setResponseStatus(webRequest);

		if (returnValue == null) {
			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
				disableContentCachingIfNecessary(webRequest);
				mavContainer.setRequestHandled(true);
				return;
			}
		}
		else if (StringUtils.hasText(getResponseStatusReason())) {
			mavContainer.setRequestHandled(true);
			return;
		}

		mavContainer.setRequestHandled(false);
		Assert.state(this.returnValueHandlers != null, "No return value handlers");
		try {
			// 处理返回值，比如@ResponseBody就是在此处执行
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}
		catch (Exception ex) {
			if (logger.isTraceEnabled()) {
				logger.trace(formatErrorForReturnValue(returnValue), ex);
			}
			throw ex;
		}
	}

4.总结

本文对Spring MVC执行请求过程做了核心方法的讲解，只解释了一小部分源码。Spring MVC有九大组件，不同组件负责处理入参、结果、视图、异常等等，功能非常强大。

参考：https://blog.csdn.net/qq_44891295/article/details/116809998
https://zhuanlan.zhihu.com/p/354131900
https://blog.csdn.net/weixin_38413579/article/details/97939757