SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)

SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)

本文基于 Spring Framework 6.2.x(Spring Boot 3.4.x 所对应版本)源码编写,源码为开源项目 spring-projects/spring-framework(Apache 2.0 协议),文中引用均为学习目的的片段摘录,版权归原项目作者所有。

上一篇我们分析了 SpringMVC 的数据绑定与类型转换,Converter/Formatter/WebDataBinder 体系解决了"请求参数怎么变成方法入参"的问题。到这里,请求进来的路 ------从接收请求、查找 Handler、解析参数到反射调用------已经全部走完了。但 doDispatch() 里还有一段我们从(五)开始就反复跳过的代码:processDispatchResult() → render(),也就是响应出去的路------视图渲染。

本文作为 SpringMVC 阶段的收尾篇,我们把这条最后的路走完,顺便再看一个特殊分支:返回 Callable、DeferredResult 时的异步请求处理。走完这一篇,doDispatch() 的每一行就都没有秘密了。

一、概述

先回顾一下整体位置。在(五)执行流程里我们贴过 doDispatch() 的全景图:请求经过 getHandler → getHandlerAdapter → applyPreHandle → ha.handle(),方法调用得到 ModelAndView mv,然后进入后半段。现在把当时的"省略号"展开,直接看 DispatcherServlet#doDispatch() 的主干源码:

java 复制代码
				// Actually invoke the 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 ServletException("Handler dispatch failed: " + err, err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new ServletException("Handler processing failed: " + err, err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
				asyncManager.setMultipartRequestParsed(multipartRequestParsed);
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed || asyncManager.isMultipartRequestParsed()) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

这段代码里有三个我们本篇要重点展开的点:

  1. ha.handle() 之后紧跟一个判断 asyncManager.isConcurrentHandlingStarted()------如果返回值处理器启动了异步处理,这里直接 return ,后面的 postHandle、processDispatchResult 全部跳过,这是异步分支的入口;
  2. applyDefaultViewName(processedRequest, mv)------Controller 只写了 Model 没写视图名时,由 RequestToViewNameTranslator 按请求路径自动推导一个默认视图名;
  3. processDispatchResult(...)------异常解析((九)讲过)之后,只要 mv 还在,就调用 render() 渲染视图。

用一张图标注出本篇内容在 doDispatch() 中的位置:

(七)返回值处理里我们埋过一个伏笔:处理器把返回值处理完之后,要告诉 mavContainer 这个请求是"我已经直接写响应了"(setRequestHandled(true),比如 JSON),还是"只是设置了视图,后面还要走视图渲染"(比如返回 String 视图名)。本篇要讲的 render(),就是后者在后半段的归宿。

二、视图渲染

2.1 View 与 ViewResolver 接口

视图渲染的主角是两个接口。先回忆一下(二)DispatcherServlet 实例化流程里讲过的 initStrategies(),九大策略组件中有两个就是为视图渲染准备的:

java 复制代码
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);

先看 initViewResolvers() 的初始化逻辑,还是熟悉的配方------容器里找实现类 Bean,找不到就走 DispatcherServlet.properties 的默认策略:

java 复制代码
	/**
	 * Initialize the ViewResolvers used by this class.
	 * <p>If no ViewResolver beans are defined in the BeanFactory for this
	 * namespace, we default to InternalResourceViewResolver.
	 */
	private void initViewResolvers(ApplicationContext context) {
		this.viewResolvers = null;

		if (this.detectAllViewResolvers) {
			// Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
			Map<String, ViewResolver> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.viewResolvers = new ArrayList<>(matchingBeans.values());
				// We keep ViewResolvers in sorted order.
				AnnotationAwareOrderComparator.sort(this.viewResolvers);
			}
		}
		else {
			try {
				ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
				this.viewResolvers = Collections.singletonList(vr);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default ViewResolver later.
			}
		}

		// Ensure we have at least one ViewResolver, by registering
		// a default ViewResolver if no other resolvers are found.
		if (this.viewResolvers == null) {
			this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No ViewResolvers declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}
	}

再看到 ViewResolver 接口本身,位于 org.springframework.web.servlet 包下,只有一个方法:

java 复制代码
public interface ViewResolver {

	/**
	 * Resolve the given view by name.
	 * <p>Note: To allow for ViewResolver chaining, a ViewResolver should
	 * return {@code null} if a view with the given name is not defined in it.
	 * However, this is not required: Some ViewResolvers will always attempt
	 * to build View objects with the given name, unable to return {@code null}
	 * (rather throwing an exception when View creation failed).
	 * @param viewName name of the view to resolve
	 * @param locale the Locale in which to resolve the view.
	 * ViewResolvers that support internationalization should respect this.
	 * @return the View object, or {@code null} if not found
	 * (optional, to allow for ViewResolver chaining)
	 * @throws Exception if the view cannot be resolved
	 * (typically in case of problems creating an actual View object)
	 */
	@Nullable
	View resolveViewName(String viewName, Locale locale) throws Exception;

}

javadoc 里专门强调了链式调用 的设计意图:找不到视图时应该返回 null 而不是抛异常,这样多个 ViewResolver 才能依次接力。又是熟悉的套路------接口 + 一堆实现类,按顺序遍历,谁解析出来谁赢,和参数解析器、返回值处理器一模一样。

解析出来的 View 接口长这样(常量部分略):

java 复制代码
public interface View {

	// ...(略)三个请求属性常量定义

	@Nullable
	default String getContentType() {
		return null;
	}

	/**
	 * Render the view given the specified model.
	 * <p>The first step will be preparing the request: In the JSP case, this would mean
	 * setting model objects as request attributes. The second step will be the actual
	 * rendering of the view, for example including the JSP via a RequestDispatcher.
	 * @param model a Map with name Strings as keys and corresponding model
	 * objects as values (Map can also be {@code null} in case of empty model)
	 * @param request current HTTP request
	 * @param response he HTTP response we are building
	 * @throws Exception if rendering failed
	 */
	void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
			throws Exception;

}

render() 的 javadoc 也说得很直白:第一步准备请求(JSP 场景就是把 Model 塞成 request 属性),第二步真正渲染(通过 RequestDispatcher 渲染 JSP)。

整体体系一图胜千言:

用表格整理常用的 ViewResolver 实现(SpringBoot 环境下 Thymeleaf 的 ThymeleafViewResolver 由 starter 自动注册):

ViewResolver 说明
InternalResourceViewResolver 默认策略,JSP 场景,最终转发到 JSP/Servlet
ContentNegotiatingViewResolver 不自己解析,根据 Accept 内容协商,从所有候选视图里挑一个
BeanNameViewResolver 按 Bean 名字匹配视图
ThymeleafViewResolver Thymeleaf 模板引擎(spring-boot-starter-thymeleaf 自动配置)
FreeMarkerViewResolver / GroovyMarkupViewResolver 等 其他模板引擎

2.2 render():从视图名到页面输出

回顾完体系,接下来按执行顺序看主流程。首先是 applyDefaultViewName()------只有当 mv 存在且没有设置任何视图时才会触发默认推导:

java 复制代码
	/**
	 * Do we need view name translation?
	 */
	private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
		if (mv != null && !mv.hasView()) {
			String defaultViewName = getDefaultViewName(request);
			if (defaultViewName != null) {
				mv.setViewName(defaultViewName);
			}
		}
	}

	/**
	 * Translate the supplied request into a default view name.
	 * @param request current HTTP servlet request
	 * @return the view name (or {@code null} if no default found)
	 * @throws Exception if view name translation failed
	 */
	@Nullable
	protected String getDefaultViewName(HttpServletRequest request) throws Exception {
		return (this.viewNameTranslator != null ? this.viewNameTranslator.getViewName(request) : null);
	}

RequestToViewNameTranslator 接口只有一个方法,把"没有视图名的请求"翻译成视图名:

java 复制代码
public interface RequestToViewNameTranslator {

	/**
	 * Translate the given {@link HttpServletRequest} into a view name.
	 * @param request the incoming {@link HttpServletRequest} providing
	 * the context from which a view name is to be resolved
	 * @return the view name, or {@code null} if no default found
	 * @throws Exception if view name translation fails
	 */
	@Nullable
	String getViewName(HttpServletRequest request) throws Exception;

}

默认实现是 DefaultRequestToViewNameTranslator,规则很简单:去掉路径首尾斜杠和文件扩展名,再拼上配置的前后缀。源码注释里给的官方例子一目了然:

java 复制代码
	@Override
	public String getViewName(HttpServletRequest request) {
		String path = ServletRequestPathUtils.getCachedPathValue(request);
		String viewName = this.prefix + transformPath(path) + this.suffix;
		if (viewName.startsWith(UrlBasedViewResolver.REDIRECT_URL_PREFIX)) {
			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Rejected path '" + path + "' with 'redirect:' prefix");
		}
		if (viewName.startsWith(UrlBasedViewResolver.FORWARD_URL_PREFIX)) {
			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Rejected path '" + path + "' with 'forward:' prefix");
		}
		return viewName;
	}

	/**
	 * Transform the request URI (in the context of the webapp) stripping
	 * slashes and extensions, and replacing the separator as required.
	 * @param lookupPath the lookup path for the current request,
	 * as determined by the UrlPathHelper
	 * @return the transformed path, with slashes and extensions stripped
	 * if desired
	 */
	protected String transformPath(String lookupPath) {
		String path = lookupPath;
		if (this.stripLeadingSlash && path.startsWith(SLASH)) {
			path = path.substring(1);
		}
		if (this.stripTrailingSlash && path.endsWith(SLASH)) {
			path = path.substring(0, path.length() - 1);
		}
		if (this.stripExtension) {
			path = StringUtils.stripFilenameExtension(path);
		}
		if (!SLASH.equals(this.separator)) {
			path = StringUtils.replace(path, SLASH, this.separator);
		}
		return path;
	}

javadoc 里的三个例子:

  • http://localhost:8080/gamecast/display.html → 视图名 display
  • http://localhost:8080/gamecast/displayShoppingCart.html → 视图名 displayShoppingCart
  • http://localhost:8080/gamecast/admin/index.html → 视图名 admin/index

这个机制在 Controller 返回 void 或者只写了 Model 的时候生效(javadoc 里还有一个细节值得注意:推导出来的视图名如果以 redirect:/forward: 开头会直接 400 拒绝,防止把用户请求路径当重定向用)。约定优先于配置,老牌 SpringMVC 项目的"约定式跳转"就是靠它。

接着走到 processDispatchResult()------(九)异常处理里我们分析过它的前半段(异常解析成 mv),现在看后半段:

java 复制代码
	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {

		boolean errorView = false;

		if (exception != null) {
			if (exception instanceof ModelAndViewDefiningException mavDefiningException) {
				logger.debug("ModelAndViewDefiningException encountered", exception);
				mv = mavDefiningException.getModelAndView();
			}
			else {
				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
				mv = processHandlerException(request, response, handler, exception);
				errorView = (mv != null);
			}
		}

		// 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 (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			// Concurrent handling started during a forward
			return;
		}

		if (mappedHandler != null) {
			// Exception (if any) is already handled..
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

两个 mv 来源汇合到同一个渲染动作:正常返回的 mv ,以及异常解析出来的错误页 mv (errorView 标记,错误页渲染完还要清理错误属性)。render() 之前先检查 wasCleared()------ModelAndViewDefiningException 等场景可能已经 clear 过了。

最后到达本篇的核心方法 render():

java 复制代码
	protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
		// Determine locale for request and apply it to the response.
		Locale locale =
				(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
		response.setLocale(locale);

		View view;
		String viewName = mv.getViewName();
		if (viewName != null) {
			// We need to resolve the view name.
			view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
			if (view == null) {
				throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
						"' in servlet with name '" + getServletName() + "'");
			}
		}
		else {
			// No need to lookup: the ModelAndView object contains the actual View object.
			view = mv.getView();
			if (view == null) {
				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
						"View object in servlet with name '" + getServletName() + "'");
			}
		}

		if (view instanceof SmartView smartView) {
			smartView.resolveNestedViews(this::resolveViewNameInternal, locale);
		}

		// Delegate to the View object for rendering.
		if (logger.isTraceEnabled()) {
			logger.trace("Rendering view [" + view + "] ");
		}
		try {
			if (mv.getStatus() != null) {
				request.setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, mv.getStatus());
				response.setStatus(mv.getStatus().value());
			}
			view.render(mv.getModelInternal(), request, response);
		}
		catch (Exception ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Error rendering view [" + view + "]", ex);
			}
			throw ex;
		}
	}

步骤拆开看:

  1. 确定 Locale ------LocaleResolver((二)里的九大策略之一)解析出语言环境,设置到响应上,国际化视图解析要用;
  2. 视图名 → View 对象 ------mv 里是逻辑视图名就调 resolveViewName() 解析;直接持有 View 对象(比如 ModelAndView 里 set 了视图、或者 redirect: 前缀场景直接构造的 RedirectView)就跳过解析。两种都为空直接抛 ServletException;
  3. SmartView.resolveNestedViews() 是 6.2 新增的逻辑,配合 FragmentsRendering 片段渲染解析嵌套视图,日常用不到,知道即可;
  4. 委托给 View 渲染 ------mv 上的自定义状态码先应用,然后 view.render(model, request, response),Model 数据在这里合并进视图。

resolveViewName() 的实现就是 2.1 说的链式遍历:

java 复制代码
	@Nullable
	private View resolveViewNameInternal(String viewName, Locale locale) throws Exception {
		if (this.viewResolvers != null) {
			for (ViewResolver viewResolver : this.viewResolvers) {
				View view = viewResolver.resolveViewName(viewName, locale);
				if (view != null) {
					return view;
				}
			}
		}
		return null;
	}

按注册顺序遍历,第一个返回非 null 的解析器胜出 ------如果全都返回 null,render() 里那个 Could not resolve view with name 'xxx' 的 ServletException 就是新手最常见的报错之一,读完源码你就知道它的确切来源了。

2.3 AbstractCachingViewResolver 缓存与 InternalResourceView:JSP 转发

再看到最常用解析器的实现。大多数 ViewResolver 都继承自 AbstractCachingViewResolver,它在接口之上加了一层视图缓存------毕竟同一个视图名每次请求都重新创建 View 对象太浪费。javadoc 里那句"View state doesn't change during the running of the application, so implementations are free to cache views"说的就是 View 是无状态的、可以放心缓存:

java 复制代码
	@Override
	@Nullable
	public View resolveViewName(String viewName, Locale locale) throws Exception {
		if (!isCache()) {
			return createView(viewName, locale);
		}
		else {
			Object cacheKey = getCacheKey(viewName, locale);
			View view = this.viewAccessCache.get(cacheKey);
			if (view == null) {
				synchronized (this.viewCreationCache) {
					view = this.viewCreationCache.get(cacheKey);
					if (view == null) {
						// Ask the subclass to create the View object.
						view = createView(viewName, locale);
						if (view == null && this.cacheUnresolved) {
							view = UNRESOLVED_VIEW;
						}
						if (view != null && this.cacheFilter.filter(view, viewName, locale)) {
							this.viewAccessCache.put(cacheKey, view);
							this.viewCreationCache.put(cacheKey, view);
						}
					}
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace(formatKey(cacheKey) + "served from cache");
				}
			}
			return (view != UNRESOLVED_VIEW ? view : null);
		}
	}

缓存设计有两个细节值得留意:

  • 两级缓存 :viewAccessCache 是 ConcurrentHashMap,无锁快速命中;viewCreationCache 是 LRU 的 LinkedHashMap(容量默认 DEFAULT_CACHE_LIMIT = 1024),创建视图时加锁防并发重复创建。先查快缓存,miss 后再在锁内查慢缓存;
  • UNRESOLVED_VIEW 占位对象 :视图名解析失败返回 null 的结果也会被缓存(cacheUnresolved 默认 true),避免同一个"解析不到"的请求反复进锁。返回时把占位对象还原成 null,对调用方透明。

JSP 场景的默认策略 InternalResourceViewResolver 本身很薄,继承 UrlBasedViewResolver 的前后缀拼接(prefix + viewName + suffix 拼出资源路径),自己只做两件事:

java 复制代码
	@Override
	protected Class<?> requiredViewClass() {
		return InternalResourceView.class;
	}

	@Override
	protected AbstractUrlBasedView buildView(String viewName) throws Exception {
		InternalResourceView view = (InternalResourceView) super.buildView(viewName);
		if (this.alwaysInclude != null) {
			view.setAlwaysInclude(this.alwaysInclude);
		}
		view.setPreventDispatchLoop(true);
		return view;
	}

setPreventDispatchLoop(true) 防止"视图路径和请求路径相同"造成转发死循环。真正干活的是 InternalResourceView#renderMergedOutputModel()(在父类 AbstractView#render() 里合并完 Model 后回调这个模板方法):

java 复制代码
	/**
	 * Render the internal resource given the specified model.
	 * This includes setting the model as request attributes.
	 */
	@Override
	protected void renderMergedOutputModel(
			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

		// Expose the model object as request attributes.
		exposeModelAsRequestAttributes(model, request);

		// Expose helpers as request attributes, if any.
		exposeHelpers(request);

		// Determine the path for the request dispatcher.
		String dispatcherPath = prepareForRendering(request, response);

		// Obtain a RequestDispatcher for the target resource (typically a JSP).
		RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
		if (rd == null) {
			throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
					"]: Check that the corresponding file exists within your web application archive!");
		}

		// If already included or response already committed, perform include, else forward.
		if (useInclude(request, response)) {
			response.setContentType(getContentType());
			if (logger.isDebugEnabled()) {
				logger.debug("Including [" + getUrl() + "]");
			}
			rd.include(request, response);
		}

		else {
			// Note: The forwarded resource is supposed to determine the content type itself.
			if (logger.isDebugEnabled()) {
				logger.debug("Forwarding to [" + getUrl() + "]");
			}
			rd.forward(request, response);
		}
	}

这就是 View 接口 javadoc 里那两步的落地:先把 Model 暴露成 request 属性 (这就是为什么 JSP 里能用 ${user.name} 直接取值),然后拿 RequestDispatcher forward 到 JSP,渲染交给 Servlet 容器和 JSP 引擎完成。SpringMVC 自己不画页面,它只负责把数据和路径准备好。

Thymeleaf 场景一句话:spring-boot-starter-thymeleaf 自动注册 ThymeleafViewResolver + ThymeleafView,套路完全一样,只是 renderMergedOutputModel() 换成了把 Model 并入 Thymeleaf 的执行上下文、由模板引擎渲染出 HTML 再写响应,不再走 Servlet 转发。后面的 Demo 用的就是它。

2.4 ContentNegotiatingViewResolver:内容协商选视图

ContentNegotiatingViewResolver 比较特殊,它不生产视图,只做视图的搬运工 ------把同一个视图名交给容器里所有其他 ViewResolver 各解析一遍,收集全部候选视图,再根据客户端的 Accept 头挑一个最合适的。看它的 resolveViewName():

java 复制代码
	@Override
	@Nullable
	public View resolveViewName(String viewName, Locale locale) throws Exception {
		RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
		Assert.state(attrs instanceof ServletRequestAttributes, "No current ServletRequestAttributes");
		List<MediaType> requestedMediaTypes = getMediaTypes(((ServletRequestAttributes) attrs).getRequest());
		if (requestedMediaTypes != null) {
			List<View> candidateViews = getCandidateViews(viewName, locale, requestedMediaTypes);
			View bestView = getBestView(candidateViews, requestedMediaTypes, attrs);
			if (bestView != null) {
				return bestView;
			}
		}

		String mediaTypeInfo = (logger.isDebugEnabled() && requestedMediaTypes != null ?
				" given " + requestedMediaTypes : "");

		if (this.useNotAcceptableStatusCode) {
			if (logger.isDebugEnabled()) {
				logger.debug("Using 406 NOT_ACCEPTABLE" + mediaTypeInfo);
			}
			return NOT_ACCEPTABLE_VIEW;
		}
		else {
			logger.debug("View remains unresolved" + mediaTypeInfo);
			return null;
		}
	}

三步走:getMediaTypes() 算出客户端可接受类型(Accept 头协商结果 ∩ 系统能生产的类型,和(七)里 writeWithMessageConverters 的协商思路如出一辙),然后收集候选视图、选最优视图。候选视图怎么收集的:

java 复制代码
	private List<View> getCandidateViews(String viewName, Locale locale, List<MediaType> requestedMediaTypes)
			throws Exception {

		List<View> candidateViews = new ArrayList<>();
		if (this.viewResolvers != null) {
			Assert.state(this.contentNegotiationManager != null, "No ContentNegotiationManager set");
			for (ViewResolver viewResolver : this.viewResolvers) {
				View view = viewResolver.resolveViewName(viewName, locale);
				if (view != null) {
					candidateViews.add(view);
				}
				for (MediaType requestedMediaType : requestedMediaTypes) {
					List<String> extensions = this.contentNegotiationManager.resolveFileExtensions(requestMediaType);
					for (String extension : extensions) {
						String viewNameWithExtension = viewName + '.' + extension;
						view = viewResolver.resolveViewName(viewNameWithExtension, locale);
						if (view != null) {
							candidateViews.add(view);
						}
					}
				}
			}
		}
		if (!CollectionUtils.isEmpty(this.defaultViews)) {
			candidateViews.addAll(this.defaultViews);
		}
		return candidateViews;
	}

两层候选:每个 ViewResolver 解析一遍原始视图名;再拿媒体类型对应的扩展名(如 json、xml)拼成 viewName.json 逐个试。最后 getBestView() 拍板:

java 复制代码
	@Nullable
	private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes, RequestAttributes attrs) {
		for (View candidateView : candidateViews) {
			if (candidateView instanceof SmartView smartView) {
				if (smartView.isRedirectView()) {
					return candidateView;
				}
			}
		}
		for (MediaType mediaType : requestedMediaTypes) {
			for (View candidateView : candidateViews) {
				if (StringUtils.hasText(candidateView.getContentType())) {
					MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
					if (mediaType.isCompatibleWith(candidateContentType)) {
						mediaType = mediaType.removeQualityValue();
						if (logger.isDebugEnabled()) {
							logger.debug("Selected '" + mediaType + "' given " + requestedMediaTypes);
						}
						attrs.setAttribute(View.SELECTED_CONTENT_TYPE, mediaType, RequestAttributes.SCOPE_REQUEST);
						return candidateView;
					}
				}
			}
		}
		return null;
	}

规则两条,优先级从高到低:

  1. 重定向视图无条件优先 ------候选里只要有 RedirectView 直接返回;
  2. 按 requestedMediaTypes 顺序找第一个 contentType 兼容的候选视图 ,并把选中的类型存进 request 属性(View.SELECTED_CONTENT_TYPE)。

都找不到时,useNotAcceptableStatusCode 为 true 就返回一个匿名 NOT_ACCEPTABLE_VIEW(渲染时只做一件事:response.setStatus(406)),否则返回 null 交给链上的下一个 ViewResolver。同一个页面既能出 HTML 又能出 JSON 的老需求,就是靠它实现的。

三、异步请求

3.1 为什么要异步

视图渲染讲完,再回头看 2.2 开头那段 doDispatch() 里的"不速之客":asyncManager.isConcurrentHandlingStarted()。

Tomcat 的工作线程池是有限的(默认 200 个 http-nio-8080-exec-* 线程)。Controller 里如果有一个耗时 10 秒的慢请求(调第三方接口、复杂计算),它就会占住一个容器工作线程 10 秒。并发一高,线程池耗尽,整个应用所有请求都得排队------慢请求把快请求也拖死了。

Servlet 3.0 开始提供了异步处理能力:request.startAsync() 之后,容器工作线程可以立即归还线程池,但响应保持打开 ;业务逻辑在别的线程里慢慢跑,跑完通过 AsyncContext.dispatch() 重新派发请求,容器再分一个线程接着写响应。SpringMVC 把这套机制封装成了返回 Callable/DeferredResult/WebAsyncTask 三种写法。

先看 Spring 侧的抽象 AsyncWebRequest 接口(spring-web 模块),关键两个方法:

java 复制代码
	/**
	 * Mark the start of asynchronous request processing so that when the main
	 * processing thread exits, the response remains open for further processing
	 * in another thread.
	 * @throws IllegalStateException if async processing has completed or is not supported
	 */
	void startAsync();

	/**
	 * Dispatch the request to the container in order to resume processing after
	 * concurrent execution in an application thread.
	 */
	void dispatch();

startAsync() 标记异步开始(实现类 StandardServletAsyncWebRequest 里会校验 servlet 和所有 filter 都开了 async 支持,然后包装出 AsyncContext),dispatch() 重新派发请求让容器恢复处理。配合超时、错误、完成三个回调注册方法,构成了 WebAsyncManager 的底座。

3.2 Callable 全流程

以最常用的 Callable 为例走一遍全流程。入口还是返回值处理器((七)2.3 的表格里,它排在第 8 位):

java 复制代码
public class CallableMethodReturnValueHandler implements HandlerMethodReturnValueHandler {

	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		return Callable.class.isAssignableFrom(returnType.getParameterType());
	}

	@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

		if (returnValue == null) {
			mavContainer.setRequestHandled(true);
			return;
		}

		Callable<?> callable = (Callable<?>) returnValue;
		WebAsyncUtils.getAsyncManager(webRequest).startCallableProcessing(callable, mavContainer);
	}

Controller 返回 Callable 时走到这里,mavContainer 连同 Callable 一起交给 WebAsyncManager.startCallableProcessing()。这个方法比较长,是异步处理的核心,全文贴出:

java 复制代码
	@SuppressWarnings("NullAway")
	public void startCallableProcessing(final WebAsyncTask<?> webAsyncTask, Object... processingContext)
			throws Exception {

		Assert.notNull(webAsyncTask, "WebAsyncTask must not be null");
		Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");

		if (!this.state.compareAndSet(State.NOT_STARTED, State.ASYNC_PROCESSING)) {
			throw new IllegalStateException(
					"Unexpected call to startCallableProcessing: [" + this.state.get() + "]");
		}

		Long timeout = webAsyncTask.getTimeout();
		if (timeout != null) {
			this.asyncWebRequest.setTimeout(timeout);
		}

		AsyncTaskExecutor executor = webAsyncTask.getExecutor();
		if (executor != null) {
			this.taskExecutor = executor;
		}

		List<CallableProcessingInterceptor> interceptors = new ArrayList<>();
		interceptors.add(webAsyncTask.getInterceptor());
		interceptors.addAll(this.callableInterceptors.values());
		interceptors.add(timeoutCallableInterceptor);

		final Callable<?> callable = webAsyncTask.getCallable();
		final CallableInterceptorChain interceptorChain = new CallableInterceptorChain(interceptors);

		this.asyncWebRequest.addTimeoutHandler(() -> {
			if (logger.isDebugEnabled()) {
				logger.debug("Servlet container timeout notification for " + formatUri(this.asyncWebRequest));
			}
			Object result = interceptorChain.triggerAfterTimeout(this.asyncWebRequest, callable);
			if (result != CallableProcessingInterceptor.RESULT_NONE) {
				setConcurrentResultAndDispatch(result);
			}
		});

		this.asyncWebRequest.addErrorHandler(ex -> {
			if (logger.isDebugEnabled()) {
				logger.debug("Servlet container error notification for " + formatUri(this.asyncWebRequest) + ": " + ex);
			}
			if (DisconnectedClientHelper.isClientDisconnectedException(ex)) {
				ex = new AsyncRequestNotUsableException(
						"Servlet container error notification for disconnected client", ex);
			}
			Object result = interceptorChain.triggerAfterError(this.asyncWebRequest, callable, ex);
			result = (result != CallableProcessingInterceptor.RESULT_NONE ? result : ex);
			setConcurrentResultAndDispatch(result);
		});

		this.asyncWebRequest.addCompletionHandler(() ->
				interceptorChain.triggerAfterCompletion(this.asyncWebRequest, callable));

		interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, callable);
		startAsyncProcessing(processingContext);
		try {
			Future<?> future = this.taskExecutor.submit(() -> {
				Object result = null;
				try {
					interceptorChain.applyPreProcess(this.asyncWebRequest, callable);
					result = callable.call();
				}
				catch (Throwable ex) {
					result = ex;
				}
				finally {
					result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, result);
				}
				setConcurrentResultAndDispatch(result);
			});
			interceptorChain.setTaskFuture(future);
		}
		catch (Throwable ex) {
			Object result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, ex);
			setConcurrentResultAndDispatch(result);
		}
	}

逐段解读:

  • 状态机 CAS :State.NOT_STARTED → ASYNC_PROCESSING,重复启动直接抛异常。6.2.x 源码里这个状态机是显式的三态枚举(NOT_STARTED/ASYNC_PROCESSING/RESULT_SET,5.3.33 引入);
  • 超时与线程池配置 :WebAsyncTask 带的超时、线程池在这里生效(普通 Callable 没有,走默认值);
  • 三个回调 :超时、错误、完成,分别在容器触发对应事件时回调拦截器链,超时/错误的兜底结果最终都汇入 setConcurrentResultAndDispatch();
  • startAsyncProcessing() :保存处理上下文(mavContainer 就在里面,二次派发时要取回来用),然后 asyncWebRequest.startAsync()------Servlet 异步在这一刻启动;
  • 线程池执行 :taskExecutor.submit(...) 里就是三步------拦截器 applyPreProcess → callable.call() 执行我们的业务逻辑 → applyPostProcess,最后 setConcurrentResultAndDispatch(result)。注意异常不会抛出去,而是作为 result 保存,留给二次派发后的异常解析流程((九))处理。

再看 startAsyncProcessing() 和 setConcurrentResultAndDispatch():

java 复制代码
	private void startAsyncProcessing(Object[] processingContext) {
		synchronized (WebAsyncManager.this) {
			this.concurrentResult = RESULT_NONE;
			this.concurrentResultContext = processingContext;
		}

		Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
		if (logger.isDebugEnabled()) {
			logger.debug("Started async request for " + formatUri(this.asyncWebRequest));
		}

		this.asyncWebRequest.startAsync();
	}

	private void setConcurrentResultAndDispatch(@Nullable Object result) {
		Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
		synchronized (WebAsyncManager.this) {
			if (!this.state.compareAndSet(State.ASYNC_PROCESSING, State.RESULT_SET)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Async result already set: [" + this.state.get() + "], " +
							"ignored result for " + formatUri(this.asyncWebRequest));
				}
				return;
			}

			this.concurrentResult = result;
			if (logger.isDebugEnabled()) {
				logger.debug("Async result set for " + formatUri(this.asyncWebRequest));
			}

			if (this.asyncWebRequest.isAsyncComplete()) {
				if (logger.isDebugEnabled()) {
					logger.debug("Async request already completed for " + formatUri(this.asyncWebRequest));
				}
				return;
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Performing async dispatch for " + formatUri(this.asyncWebRequest));
			}
			this.asyncWebRequest.dispatch();
		}
	}

dispatch() 触发容器把请求重新派发回 DispatcherServlet 。于是 doDispatch() 第二次执行,这一次 ha.handle() 内部会先检查有没有已保存的异步结果。看 RequestMappingHandlerAdapter#invokeHandlerMethod() 的关键段:

java 复制代码
		if (asyncManager.hasConcurrentResult()) {
			Object result = asyncManager.getConcurrentResult();
			Object[] resultContext = asyncManager.getConcurrentResultContext();
			Assert.state(resultContext != null && resultContext.length > 0, "Missing result context");
			mavContainer = (ModelAndViewContainer) resultContext[0];
			asyncManager.clearConcurrentResult();
			LogFormatUtils.traceDebug(logger, traceOn -> {
				String formatted = LogFormatUtils.formatValue(result, !traceOn);
				return "Resume with async result [" + formatted + "]";
			});
			invocableMethod = invocableMethod.wrapConcurrentResult(result);
		}

		invocableMethod.invokeAndHandle(webRequest, mavContainer);

妙就��在这里:二次派发时不重新执行 Controller 方法 ,而是把 callable.call() 的结果包装进 invocableMethod,让它"冒充"这次的返回值,走一遍完整的返回值处理(@RestController 写 JSON、返回 String 走视图名渲染,都和第一次一样)。如果结果是异常,同样会走(九)异常处理的流程。而且上次保存的 mavContainer 也从上下文里取回来了,模型数据不丢。

用一张时序图把整个流程串起来(重点看 Servlet 线程在什么时刻被释放、请求如何二次进入 doDispatch):

3.3 DeferredResult:外部线程唤醒

Callable 的执行是"发起即执行",但有些场景业务结果不是当前线程能产出的:比如消息队列消费者回调、定时任务轮询结果、长轮询推送。这时用 DeferredResult------它只是一个等待结果的容器,由任何外部线程在任意时刻 setResult() 唤醒。

先看返回值处理器:

java 复制代码
	@SuppressWarnings({"deprecation", "removal"})
	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		Class<?> type = returnType.getParameterType();
		return (DeferredResult.class.isAssignableFrom(type) ||
				org.springframework.util.concurrent.ListenableFuture.class.isAssignableFrom(type) ||
				CompletionStage.class.isAssignableFrom(type));
	}

	@SuppressWarnings({"deprecation", "removal"})
	@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

		if (returnValue == null) {
			mavContainer.setRequestHandled(true);
			return;
		}

		DeferredResult<?> result;

		if (returnValue instanceof DeferredResult<?> deferredResult) {
			result = deferredResult;
		}
		else if (returnValue instanceof org.springframework.util.concurrent.ListenableFuture<?> listenableFuture) {
			result = adaptListenableFuture(listenableFuture);
		}
		else if (returnValue instanceof CompletionStage<?> completionStage) {
			result = adaptCompletionStage(completionStage);
		}
		else {
			// Should not happen...
			throw new IllegalStateException("Unexpected return value type: " + returnValue);
		}

		WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(result, mavContainer);
	}

不止 DeferredResult 本身,ListenableFuture(已废弃)和 CompletionStage(CompletableFuture)也归它管,后两者被适配成 DeferredResult 再处理,比如 adaptCompletionStage():

java 复制代码
	private DeferredResult<Object> adaptCompletionStage(CompletionStage<?> future) {
		DeferredResult<Object> result = new DeferredResult<>();
		future.whenComplete((value, ex) -> {
			if (ex != null) {
				if (ex instanceof CompletionException && ex.getCause() != null) {
					ex = ex.getCause();
				}
				result.setErrorResult(ex);
			}
			else {
				result.setResult(value);
			}
		});
		return result;
	}

CompletableFuture 完成时(无论正常还是异常)自动调用 setResult/setErrorResult------所以 CompletableFuture 可以理解为"自带唤醒的 DeferredResult"。而纯 DeferredResult 的唤醒入口是 setResult(),看它的实现:

java 复制代码
	public boolean setResult(@Nullable T result) {
		return setResultInternal(result);
	}

	private boolean setResultInternal(@Nullable Object result) {
		// Immediate expiration check outside of the result lock
		if (isSetOrExpired()) {
			return false;
		}
		DeferredResultHandler resultHandlerToUse;
		synchronized (this) {
			// Got the lock in the meantime: double-check expiration status
			if (isSetOrExpired()) {
				return false;
			}
			// At this point, we got a new result to process
			this.result = result;
			resultHandlerToUse = this.resultHandler;
			if (resultHandlerToUse == null) {
				// No result handler set yet -> let the setResultHandler implementation
				// pick up the result object and invoke the result handler for it.
				return true;
			}
			// Result handler available -> let's clear the stored reference since
			// we don't need it anymore.
			this.resultHandler = null;
		}
		// If we get here, we need to process an existing result object immediately.
		// The decision is made within the result lock; just the handle call outside
		// of it, avoiding any deadlock potential with Servlet container locks.
		resultHandlerToUse.handleResult(result);
		return true;
	}

注释里的并发设计很讲究:resultHandlerToUse.handleResult(result) 的调用被刻意放在 synchronized 块外 ,注释写明是"避免与 Servlet 容器锁产生死锁"。谁在 setResultHandler() 里注册了这个 handler?回到 WebAsyncManager#startDeferredResultProcessing()(超时/错误回调与 startCallableProcessing 对称,此处省略):

java 复制代码
	@SuppressWarnings("NullAway")
	public void startDeferredResultProcessing(
			final DeferredResult<?> deferredResult, Object... processingContext) throws Exception {

		Assert.notNull(deferredResult, "DeferredResult must not be null");
		Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");

		if (!this.state.compareAndSet(State.NOT_STARTED, State.ASYNC_PROCESSING)) {
			throw new IllegalStateException(
					"Unexpected call to startDeferredResultProcessing: [" + this.state.get() + "]");
		}

		Long timeout = deferredResult.getTimeoutValue();
		if (timeout != null) {
			this.asyncWebRequest.setTimeout(timeout);
		}

		List<DeferredResultProcessingInterceptor> interceptors = new ArrayList<>();
		interceptors.add(deferredResult.getLifecycleInterceptor());
		interceptors.addAll(this.deferredResultInterceptors.values());
		interceptors.add(timeoutDeferredResultInterceptor);

		final DeferredResultInterceptorChain interceptorChain = new DeferredResultInterceptorChain(interceptors);

		// ...(略)超时/错误回调注册,与 Callable 分支对称

		this.asyncWebRequest.addCompletionHandler(() ->
				interceptorChain.triggerAfterCompletion(this.asyncWebRequest, deferredResult));

		interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, deferredResult);
		startAsyncProcessing(processingContext);

		try {
			interceptorChain.applyPreProcess(this.asyncWebRequest, deferredResult);
			deferredResult.setResultHandler(result -> {
				result = interceptorChain.applyPostProcess(this.asyncWebRequest, deferredResult, result);
				setConcurrentResultAndDispatch(result);
			});
		}
		catch (Throwable ex) {
			setConcurrentResultAndDispatch(ex);
		}
	}

流程闭环了:startDeferredResultProcessing 给 DeferredResult 注册结果回调 → 任何外部线程 调用 setResult() → 回调执行 setConcurrentResultAndDispatch(result) → dispatch() 重新派发 → 和 Callable 一样二次进入 doDispatch() 完成输出。区别只在一点:Callable 是框架替你提交执行,DeferredResult 的执行线程完全由应用自己控制。

3.4 WebAsyncTask:带超时与自定义线程池

WebAsyncTask<V> 是 Callable 的增强包装,源码注释一句话:"Holder for a Callable, a timeout value, and a task executor"。它提供四个构造器,覆盖不同组合:

java 复制代码
	/**
	 * Create a {@code WebAsyncTask} wrapping the given {@link Callable}.
	 */
	public WebAsyncTask(Callable<V> callable) {
		// ...(略)
	}

	/**
	 * Create a {@code WebAsyncTask} with a timeout value and a {@link Callable}.
	 */
	public WebAsyncTask(long timeout, Callable<V> callable) {
		// ...(略)
	}

	/**
	 * Create a {@code WebAsyncTask} with a timeout value, an executor name, and a {@link Callable}.
	 */
	public WebAsyncTask(@Nullable Long timeout, String executorName, Callable<V> callable) {
		// ...(略)
	}

	/**
	 * Create a {@code WebAsyncTask} with a timeout value, an executor instance, and a Callable.
	 */
	public WebAsyncTask(@Nullable Long timeout, AsyncTaskExecutor executor, Callable<V> callable) {
		// ...(略)
	}

此外还支持 onTimeout()/onError() 注册超时和异常的兜底回调。它的返回值处理器 AsyncTaskMethodReturnValueHandler 很短:

java 复制代码
public class AsyncTaskMethodReturnValueHandler implements HandlerMethodReturnValueHandler {

	@Nullable
	private final BeanFactory beanFactory;

	public AsyncTaskMethodReturnValueHandler(@Nullable BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}

	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		return WebAsyncTask.class.isAssignableFrom(returnType.getParameterType());
	}

	@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

		if (returnValue == null) {
			mavContainer.setRequestHandled(true);
			return;
		}

		WebAsyncTask<?> webAsyncTask = (WebAsyncTask<?>) returnValue;
		if (this.beanFactory != null) {
			webAsyncTask.setBeanFactory(this.beanFactory);
		}
		WebAsyncUtils.getAsyncManager(webRequest).startCallableProcessing(webAsyncTask, mavContainer);
	}

}

处理方式和 Callable 一模一样------WebAsyncTask 内部也实现了 CallableProcessingInterceptor,直接塞给同一个 startCallableProcessing(webAsyncTask, ...)。区别在 3.2 开头我们贴过的那几行已经生效了:

  • webAsyncTask.getTimeout() 非 null → asyncWebRequest.setTimeout(timeout) 覆盖容器默认超时;
  • webAsyncTask.getExecutor() 非 null → 替换 WebAsyncManager 默认的 SimpleAsyncTaskExecutor(注意这个默认实现每次新建线程 ,不做复用,高并发下务必换成自己的线程池------构造器传 executorName 时,setBeanFactory 注入的 beanFactory 会在启动阶段按名字从容器里解析线程池 Bean)。

3.5 与拦截器的联动:afterConcurrentHandlingStarted

异步对拦截器链有一个特别的影响。回顾(八)拦截器里讲的三个时机 preHandle/postHandle/afterCompletion,再看 doDispatch() 代码里第一节的 finally 块:

java 复制代码
			finally {
				if (asyncManager.isConcurrentHandlingStarted()) {
					// Instead of postHandle and afterCompletion
					if (mappedHandler != null) {
						mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
					}
					asyncManager.setMultipartRequestParsed(multipartRequestParsed);
				}
				else {
					// Clean up any resources used by a multipart request.
					if (multipartRequestParsed || asyncManager.isMultipartRequestParsed()) {
						cleanupMultipart(processedRequest);
					}
				}
			}

注释说得很清楚:"Instead of postHandle and afterCompletion"------异步启动后,postHandle 和 afterCompletion 都不会执行了 (此时响应还没写出来,方法也没真正完成),取而代之的是 applyAfterConcurrentHandlingStarted(),回调的是 HandlerInterceptor 的异步扩展接口:

java 复制代码
public interface AsyncHandlerInterceptor extends HandlerInterceptor {

	/**
	 * Called instead of {@code postHandle} and {@code afterCompletion}
	 * when the handler is being executed concurrently.
	 * <p>Implementations may use the provided request and response but should
	 * avoid modifying them in ways that would conflict with the concurrent
	 * execution of the handler. A typical use of this method would be to
	 * clean up thread-local variables.
	 * // ...(略)参数与异常说明
	 */
	default void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
	}

}

所以自定义拦截器想在异步场景里做资源清理、ThreadLocal 归还(呼应(八)里 ThreadLocal 的坑),必须实现 AsyncHandlerInterceptor 而不是只实现 HandlerInterceptor。等二次派发完成后,processDispatchResult() 里还有一道防线:

java 复制代码
		if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			// Concurrent handling started during a forward
			return;
		}

如果二次派发过程中(比如渲染的错误页里又触发了异步 forward)又启动了新的并发处理,afterCompletion 依然跳过,避免对同一个请求重复收尾。

四、Demo 实战验证

以上场景整理成一个可运行的 SpringBoot 3.4.5 工程(文末有完整代码地址),依赖 spring-boot-starter-web + spring-boot-starter-thymeleaf。先看 Controller 关键代码:

java 复制代码
@RestController
public class AsyncController {

    private static final Logger log = LoggerFactory.getLogger(AsyncController.class);

    @GetMapping("/callable")
    public Callable<String> callable() {
        log.info("Controller 线程:{}", Thread.currentThread().getName());
        return () -> {
            TimeUnit.SECONDS.sleep(2);   // 模拟耗时操作
            String name = Thread.currentThread().getName();
            log.info("Callable 执行线程:{}", name);
            return "done by " + name;
        };
    }

    @GetMapping("/deferred")
    public DeferredResult<String> deferred() {
        DeferredResult<String> result = new DeferredResult<>(5000L, "timeout fallback");
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // 外部线程唤醒
            result.setResult("set by " + Thread.currentThread().getName());
        }, "outer-wakeup-thread").start();
        log.info("Controller 线程:{} 已返回 DeferredResult,立即释放", Thread.currentThread().getName());
        return result;
    }

    @GetMapping("/web-async-task")
    public WebAsyncTask<String> webAsyncTask() {
        Callable<String> biz = () -> {
            TimeUnit.SECONDS.sleep(1);   // 故意比超时时间久
            return "done by " + Thread.currentThread().getName();
        };
        WebAsyncTask<String> task = new WebAsyncTask<>(800L, "bizExecutor", biz);
        // 超时兜底回调:返回值会成为异步结果,触发重新派发
        task.onTimeout(() -> "timeout fallback");
        return task;
    }
}

配置类注册自定义线程池(executorName 按名字解析的就是它):

java 复制代码
@Configuration
public class AsyncConfig {

    @Bean("bizExecutor")
    public AsyncTaskExecutor bizExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setThreadNamePrefix("biz-async-");
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        return executor;
    }
}

页面渲染与拦截器联动各来一个:

java 复制代码
@Controller
public class HomeController {

    @GetMapping("/page")
    public String page(Model model) {
        model.addAttribute("title", "视图渲染");
        model.addAttribute("items", List.of("ViewResolver 链式解析", "AbstractCachingViewResolver 缓存", "render() 委托 View"));
        return "home";    // 交给 ThymeleafViewResolver 解析 templates/home.html
    }
}
java 复制代码
@Component
public class AsyncLogInterceptor implements AsyncHandlerInterceptor {

    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request,
                                               HttpServletResponse response, Object handler) {
        System.out.println("[interceptor] afterConcurrentHandlingStarted,跳过了 postHandle/afterCompletion");
    }
}

启动后逐个请求验证(curl http://localhost:8080/xxx),结果与源码分析完全对应:

请求 返回值 关键现象(日志/响应) 对应源码结论
GET /page String 视图名 渲染出 home.html 页面,Model 三条列表可见 ViewNameMethodReturnValueHandler → render() → ThymeleafView
GET /callable Callable Controller 线程 http-nio-8080-exec-N 先打印;约 2s 后 MvcAsync1 执行 callable 并返回 done by MvcAsync1 Servlet 线程在 startAsync 后立即归还,SimpleAsyncTaskExecutor 新建 MvcAsync* 线程执行,二次派发后写响应
GET /deferred DeferredResult Controller 线程立即返回;约 2s 后响应 set by outer-wakeup-thread 外部线程 setResult → setResultHandler 回调 → dispatch 重新派发
GET /web-async-task WebAsyncTask 约 800ms 后响应 timeout fallback(Callable 休眠 1s > 超时 800ms),线程名前缀 biz-async- WebAsyncTask 超时生效,onTimeout 回调结果经 setConcurrentResultAndDispatch 派发;executorName 解析到自定义线程池
任意异步请求 --- 控制台打印 afterConcurrentHandlingStarted,且没有 postHandle 日志 finally 块分支:Instead of postHandle and afterCompletion

几个可以自己动手观察的细节:

  • /callable 请求的秒回不等于响应完成 :curl 会阻塞到二次派发写完响应,但 Tomcat 工作线程在 2 秒内早已释放,这段时间它完全可以服务其他请求(可以并行发两个 /callable 观察 exec-* 线程都不阻塞);
  • /deferred 里 Controller 方法立刻返回,日志先打印"已返回 DeferredResult",响应却在 2 秒后到达------这正是"响应保持打开"的直观体现;
  • 超时兜底返回的是 DeferredResult 构造器第二个参数(或 onTimeout 注册的回调),超时同样会走 setConcurrentResultAndDispatch 触发重新派发。

最后用一张图把本文的知识点归纳一下:

五、总结

至此 SpringMVC 阶段全部收尾。回顾整个系列:我们从(一)DispatcherServlet 的初始化与(二/三/四)九大策略组件实例化出发,(五)走通 doDispatch 执行全景,(六)(十)解决参数解析与数据绑定,(七)理清返回值处理,(八)(九)补上拦截器与异常处理两翼,本篇用 render() 打通了"响应出去的路",并用异步请求这个特殊分支收束了整个执行流程------请求进来的路和响应出去的路,每一行都走到了。

SpringMVC 的篇章到这里就全部结束了。它处理请求的整套骨架都搭建在 Spring 容器之上:九大策略组件是容器里的 Bean,拦截器从容器里收集,@ControllerAdvice 靠容器事件缓存------但我们一直没有回头去看容器本身是怎么把这些 Bean 造出来的。下个系列《Spring 源码分析(一)IOC 容器总览与 refresh() 全景》,我们进入容器内部,从 refresh() 的十三步开始,看 Bean 的定义、加载、实例化与依赖注入的全过程。


Demo 完整代码 :SpringMVC/11-视图渲染与异步/view-async-demo(SpringBoot 3.4.5 + JDK 17,mvn spring-boot:run 启动后按上表逐个请求验证)

专栏往期:

本文为「源码学习」专栏系列文章,转载请注明出处。相互学习,共同进步!

相关推荐
靠沿1 小时前
MySQL数据库进阶——存储过程和触发器
java·数据库·mysql
码少女2 小时前
MySQL--库与表的增删改查基础
java·数据库·mysql
Flynt4 小时前
掘金热文说 Spring Boot 4.1 默认开虚拟线程,我实测后发现了更狠的坑
java·spring boot·性能优化
拄杖忙学轻声码4 小时前
Spring中的 HttpHeaders.readOnlyHttpHeaders() 作用是什么
spring
Resean02234 小时前
Spring 源码分析(一)IOC 容器总览与 refresh() 全景
java·后端·spring
保利威视频SaaS小张5 小时前
企业直播接入笔记 12|企业内训直播怎么做签到和学时统计,防挂机这件事比想象中难
java·前端·数据库·笔记·视频云·polvy·polyv
开开心心就好6 小时前
两张表格数据对比工具,不用写函数也能查
算法·spring·智能手机·pdf·电脑·intellij-idea·音视频
顧棟6 小时前
【ES实战】 索引模板「可追溯、可校验」:一种模板治理的工程化思路
java·数据库·elasticsearch
玄昌盛不会编程8 小时前
LeetCode——2243. 计算字符串的数字和
java·算法·leetcode