SpringMVC请求执行流程源码解析

文章目录

• • 0.SpringMVC九大内置组件
  • 1.processRequest方法
  • • • 1.请求先到service方法
      • 2.然后不管是get还是post都会跳转到processRequest方法统一处理
  • 2.doService方法
  • 3.doDispatch方法
  • • • 1.代码
      • 2.checkMultipart
  • 4.核心流程

0.SpringMVC九大内置组件

1.processRequest方法

1.请求先到service方法

org.springframework.web.servlet.FrameworkServlet#service

2.然后不管是get还是post都会跳转到processRequest方法统一处理

org.springframework.web.servlet.FrameworkServlet#processRequest

/**
 * 处理 HTTP 请求的核心方法，负责执行 Spring MVC 的核心请求处理流程。
 * 该方法由 FrameworkServlet 调用，用于请求的前后处理、异常捕获、异步支持等。
 *
 * @param request  HttpServletRequest 对象，表示客户端的 HTTP 请求
 * @param response HttpServletResponse 对象，表示服务器返回的 HTTP 响应
 * @throws ServletException  处理 Servlet 相关异常
 * @throws IOException       处理 I/O 相关异常
 */
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
       throws ServletException, IOException {

    // 记录请求处理的开始时间（用于统计请求耗时）
    long startTime = System.currentTimeMillis();
    Throwable failureCause = null; // 记录请求处理过程中发生的异常

    // 1. 获取当前线程的 LocaleContext（国际化上下文）
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContext localeContext = buildLocaleContext(request);

    // 2. 获取当前线程的 RequestAttributes（SpringMVC 请求属性）
    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

    // 3. 获取 WebAsyncManager（用于处理异步请求）
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

    // 4. 初始化线程变量（将请求作用域信息存入 ThreadLocal）
    initContextHolders(request, localeContext, requestAttributes);

    try {
       // 5. 调用 doService 进行实际的请求处理（由子类实现，比如 DispatcherServlet）
       doService(request, response);
    }
    catch (ServletException | IOException ex) {
       failureCause = ex;  // 记录异常
       throw ex;  // 继续向上抛出异常
    }
    catch (Throwable ex) {
       failureCause = ex;  // 记录异常
       throw new NestedServletException("Request processing failed", ex);
    }

    finally {
       // 6. 还原之前的 LocaleContext 和 RequestAttributes，防止线程污染
       resetContextHolders(request, previousLocaleContext, previousAttributes);
       
       // 7. 标记请求处理完成，通知所有监听器
       if (requestAttributes != null) {
          requestAttributes.requestCompleted();
       }

       // 8. 记录请求处理结果（用于日志记录）
       logResult(request, response, failureCause, asyncManager);

       // 9. 发布请求处理完成事件（Spring 事件机制）
       publishRequestHandledEvent(request, response, startTime, failureCause);
    }
}

2.doService方法

org.springframework.web.servlet.DispatcherServlet#doService

/**
 * 处理 HTTP 请求的核心方法，负责调度 SpringMVC 请求，并将请求转发给 `doDispatch()` 进行处理。
 * 该方法由 `FrameworkServlet` 调用，主要职责包括：
 * 1. 记录请求日志
 * 2. 处理包含（include）请求
 * 3. 将 SpringMVC 组件（如 `WebApplicationContext`、`LocaleResolver`）绑定到 `request`
 * 4. 处理 FlashMap（用于跨请求传递参数）
 * 5. 解析 `RequestPath`
 * 6. 调用 `doDispatch()` 进行请求分发
 *
 * @param request  HttpServletRequest 对象，表示客户端的 HTTP 请求
 * @param response HttpServletResponse 对象，表示服务器返回的 HTTP 响应
 * @throws Exception 可能抛出的异常
 */
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
	// 1. 记录请求日志（用于调试）
	logRequest(request);

	// 2. 处理包含（include）请求（一般不用）
	// 如果请求是 include（如 JSP 的 <jsp:include>），需要保存原始的请求属性
	Map<String, Object> attributesSnapshot = null;
	if (WebUtils.isIncludeRequest(request)) {
		attributesSnapshot = new HashMap<>();
		Enumeration<?> attrNames = request.getAttributeNames();
		while (attrNames.hasMoreElements()) {
			String attrName = (String) attrNames.nextElement();
			// 只有在 cleanupAfterInclude 为 true 或者 以 `org.springframework.` 开头的属性才会保存
			if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
				attributesSnapshot.put(attrName, request.getAttribute(attrName));
			}
		}
	}

	// 3. 将 SpringMVC 相关对象存入 `request`，供 Controller 和 View 使用
	request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext()); // 绑定 WebApplicationContext
	request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver); // 绑定 LocaleResolver
	request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver); // 绑定 ThemeResolver
	request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource()); // 绑定 ThemeSource（主题源）

	// 4. 处理 FlashMap（用于跨请求数据传输，方便重定向时传递参数）
	if (this.flashMapManager != null) {
		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			// 绑定输入 FlashMap，防止多次修改
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		// 绑定输出 FlashMap（用于存储新传递的数据）
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
		request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
	}

	// 5. 解析 `RequestPath`
	RequestPath previousRequestPath = null;
	if (this.parseRequestPath) {
		// 先保存原始的 RequestPath（如果有的话）
		previousRequestPath = (RequestPath) request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
		// 解析并缓存 RequestPath
		ServletRequestPathUtils.parseAndCache(request);
	}

	try {
		// 6. 处理请求：调用 `doDispatch()` 进行请求分发
		doDispatch(request, response);
	}
	finally {
		// 7. 如果请求是 include，并且不是异步请求，则恢复原始请求属性
		if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			if (attributesSnapshot != null) {
				restoreAttributesAfterInclude(request, attributesSnapshot);
			}
		}

		// 8. 如果解析了 `RequestPath`，则恢复之前的路径信息
		if (this.parseRequestPath) {
			ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
		}
	}
}

3.doDispatch方法

1.代码

/**
 * 执行请求分发，调用对应的 `Handler` 处理 HTTP 请求。
 * <p>主要流程：
 * 1. 确定请求的处理器（Handler）和处理器适配器（HandlerAdapter）
 * 2. 处理 `Last-Modified` 头，提高 GET 请求的缓存命中率
 * 3. 执行拦截器 `preHandle()`
 * 4. 调用 `HandlerAdapter.handle()` 方法，执行控制器（Controller）
 * 5. 处理 `ModelAndView`，渲染视图
 * 6. 处理异常
 * 7. 执行拦截器 `postHandle()` 和 `afterCompletion()`
 * 8. 处理异步请求
 *
 * @param request  当前 HTTP 请求
 * @param response 当前 HTTP 响应
 * @throws Exception 处理过程中可能抛出的异常
 */
@SuppressWarnings("deprecation")
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request; // 处理后的请求对象
    HandlerExecutionChain mappedHandler = null; // 处理器链（包含处理器 + 拦截器）
    boolean multipartRequestParsed = false; // 是否解析了 multipart 请求（是否是上传请求）

    // 获取 WebAsyncManager（用于管理异步请求）
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null; // 视图模型
        Exception dispatchException = null; // 处理过程中可能抛出的异常

        try {
            // 1. 检查请求是否为 Multipart 类型（如文件上传），并进行解析
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // 2. 通过 `HandlerMapping` 获取当前请求对应的 `HandlerExecutionChain`
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response); // 404 处理
                return;
            }

            // 3. 通过 `HandlerAdapter` 获取支持该处理器的适配器（SpringMVC 允许不同的控制器风格）
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // 4. 处理 HTTP `Last-Modified` 头，提高 GET 请求的缓存命中率
            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; // 直接返回 304 Not Modified
                }
            }

            // 5. 执行拦截器 `preHandle()`，如果返回 false，直接终止请求
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // 6. 调用 `HandlerAdapter.handle()`，执行 Controller 方法
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            // 7. 检查是否为异步请求，如果是，则不继续执行后续流程
            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            // 8. 处理默认视图名称
            applyDefaultViewName(processedRequest, mv);

            // 9. 执行拦截器 `postHandle()`，此时 `ModelAndView` 还未渲染
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // 处理 `Handler` 方法中抛出的 `Error`
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }

        // 10. 处理请求结果，包括渲染视图和异常处理
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        // 11. 触发 `afterCompletion()` 方法，保证拦截器总能执行
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // 12. 如果请求是异步的，则调用拦截器的 `applyAfterConcurrentHandlingStarted()`
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // 13. 清理 multipart 请求的资源
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

2.checkMultipart

/**
 * 检查当前请求是否是 multipart（多部分）请求，并进行解析。
 * <p>如果请求是 multipart 类型（如文件上传），则使用 `MultipartResolver` 进行解析，
 * 并将请求转换为 `MultipartHttpServletRequest`，否则返回原始请求。
 *
 * <p>主要处理逻辑：
 * 1. **检查是否配置了 `MultipartResolver`**
 * 2. **检查请求是否是 multipart 类型**
 * 3. **如果请求已经被解析过，则直接返回**
 * 4. **如果解析失败过，则跳过重新解析**
 * 5. **尝试解析 multipart 请求**
 * 6. **异常处理**
 *
 * @param request 当前 HTTP 请求
 * @return 处理后的请求（如果是 multipart，则返回 `MultipartHttpServletRequest`，否则返回原始请求）
 * @throws MultipartException 如果解析 multipart 失败，则抛出异常
 * @see MultipartResolver#resolveMultipart
 */
protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
    // 1. 判断是否配置了 `MultipartResolver`，并且请求是否为 multipart 类型
    if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
        
        // 2. 如果请求已经是 `MultipartHttpServletRequest`，说明已经解析过，直接返回
        if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {
            if (DispatcherType.REQUEST.equals(request.getDispatcherType())) {
                logger.trace("Request already resolved to MultipartHttpServletRequest, e.g. by MultipartFilter");
            }
        }
        
        // 3. 如果当前请求之前解析 multipart 失败，则跳过重新解析
        else if (hasMultipartException(request)) {
            logger.debug("Multipart resolution previously failed for current request - " +
                    "skipping re-resolution for undisturbed error rendering");
        }
        
        // 4. 尝试解析 multipart 请求
        else {
            try {
                return this.multipartResolver.resolveMultipart(request);
            }
            catch (MultipartException ex) {
                // 5. 如果请求中已经存在 `ERROR_EXCEPTION_ATTRIBUTE`，说明是错误请求，记录日志后继续处理
                if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) != null) {
                    logger.debug("Multipart resolution failed for error dispatch", ex);
                    // 继续使用原始 request 进行处理
                }
                else {
                    // 6. 解析失败，抛出异常
                    throw ex;
                }
            }
        }
    }
    
    // 7. 如果请求不是 multipart，或解析失败，则返回原始请求
    return request;
}

4.核心流程