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()); // 绑定 WebApplicationContextrequest.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver); // 绑定 LocaleResolverrequest.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver); // 绑定 ThemeResolverrequest.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);// 解析并缓存 RequestPathServletRequestPathUtils.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.核心流程