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);
}
}
}
}
这段代码里有三个我们本篇要重点展开的点:
ha.handle()之后紧跟一个判断asyncManager.isConcurrentHandlingStarted()------如果返回值处理器启动了异步处理,这里直接 return ,后面的postHandle、processDispatchResult全部跳过,这是异步分支的入口;applyDefaultViewName(processedRequest, mv)------Controller 只写了 Model 没写视图名时,由RequestToViewNameTranslator按请求路径自动推导一个默认视图名;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→ 视图名displayhttp://localhost:8080/gamecast/displayShoppingCart.html→ 视图名displayShoppingCarthttp://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;
}
}
步骤拆开看:
- 确定 Locale ------
LocaleResolver((二)里的九大策略之一)解析出语言环境,设置到响应上,国际化视图解析要用; - 视图名 → View 对象 ------
mv里是逻辑视图名就调resolveViewName()解析;直接持有View对象(比如ModelAndView里 set 了视图、或者redirect:前缀场景直接构造的RedirectView)就跳过解析。两种都为空直接抛ServletException; SmartView.resolveNestedViews()是 6.2 新增的逻辑,配合FragmentsRendering片段渲染解析嵌套视图,日常用不到,知道即可;- 委托给 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;
}
规则两条,优先级从高到低:
- 重定向视图无条件优先 ------候选里只要有
RedirectView直接返回; - 按 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 启动后按上表逐个请求验证)
专栏往期:
- SpringMVC 6+源码分析(一)初始化流程
- SpringMVC 6+源码分析(二)DispatcherServlet实例化流程 1
- SpringMVC 6+源码分析(三)DispatcherServlet实例化流程 2
- SpringMVC 6+源码分析(四)DispatcherServlet实例化流程 3------HandlerAdapter初始化
- SpringMVC 6+源码分析(五)执行流程
- SpringMVC 6+源码分析(六)参数处理
- (七)返回值处理
- (八)拦截器
- (九)异常处理
- (十)数据绑定与类型转换
本文为「源码学习」专栏系列文章,转载请注明出处。相互学习,共同进步!