SpringMVC 6+源码分析(九)异常处理
本文基于 Spring Framework 6.2.x(Spring Boot 3.4.x 所对应版本)源码编写,源码为开源项目 spring-projects/spring-framework(Apache 2.0 协议),文中引用均为学习目的的片段摘录,版权归原项目作者所有。
上一篇我们分析了拦截器 HandlerInterceptor 的三个回调时机,其中提到一个细节:请求一旦在执行过程中抛出异常,postHandle 会被跳过,但 afterCompletion 依然会执行。那么问题来了:那条异常并没有凭空消失,它到底被谁接走了?我们平时写的 @ExceptionHandler、@ControllerAdvice,又是怎么挂到这条异常处理链上的?
本文我们就顺着"异常"这条线往下看,也就是 HandlerExceptionResolver 体系。
一、概述
先回顾一下整体位置。在专栏(五)执行流程里我们讲到,DispatcherServlet#doDispatch() 是整个请求分发的总入口:先找 Handler、找 Adapter、走拦截器前置,然后 ha.handle() 调用 Controller 方法(参数解析和返回值处理分别是上一篇和(七)的内容)。这个方法的结构其实是一个双层 try/catch :内层 catch 把执行过程中抛出的异常先"接住",存进 dispatchException 变量,然后统一交给 processDispatchResult() 善后------异常处理就发生在 ha.handle() 抛出异常之后、render() 渲染视图之前。
用一张图标注出异常处理在整个执行流程中的位置:

如果你读了这个专栏的前几篇,应该对 SpringMVC 组件设计的那个经典套路有印象了:接口 + Composite 门面 + 一堆实现类,按注册顺序遍历,谁先接手谁负责 。参数解析器((六))、返回值处理器((七))都是这么玩的,异常解析器也不例外------DispatcherServlet 持有一组 HandlerExceptionResolver,processHandlerException() 里按顺序遍历,第一个返回非 null 的胜出。
另外,这套 resolver 的注册时机其实我们早就见过了。专栏(二)讲 DispatcherServlet 实例化流程时,onRefresh() → initStrategies() 里初始化过九大策略组件,其中一行就是 initHandlerExceptionResolvers(context)。本文会把这个方法重新翻出来细看。
所以本文的分析方式和前两篇类似:先看接口体系和初始化,再看执行流程和匹配规则,最后逐个看几个默认实现类,并用 demo 验证。
二、HandlerExceptionResolver 体系
2.1 HandlerExceptionResolver 接口
接口位于 spring-webmvc 模块的 org.springframework.web.servlet 包下,是 SpringMVC 里资格最老的接口之一(javadoc 里写着 @since 22.11.2003),只有一个方法:
java
public interface HandlerExceptionResolver {
/**
* Try to resolve the given exception that got thrown during handler execution,
* returning a {@link ModelAndView} that represents a specific error page if appropriate.
* <p>The returned {@code ModelAndView} may be {@linkplain ModelAndView#isEmpty() empty}
* to indicate that the exception has been resolved successfully but that no view
* should be rendered, for instance by setting a status code.
* @param request current HTTP request
* @param response current HTTP response
* @param handler the executed handler, or {@code null} if none chosen at the
* time of the exception (for example, if multipart resolution failed)
* @param ex the exception that got thrown during handler execution
* @return a corresponding {@code ModelAndView} to forward to,
* or {@code null} for default processing in the resolution chain
*/
@Nullable
ModelAndView resolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
}
javadoc 里有几处非常关键的信息,划一下重点:
- 返回一个
ModelAndView,代表"异常被解析成了错误页面",交给后续的render()渲染; - 返回的
ModelAndView可以是"空"的 (isEmpty()),表示"异常我处理完了,但不需要渲染视图"------比如只是设置了个状态码。这个语义后面 3.4 节会反复用到; - 返回 null 表示"这个异常我不处理,链上下一个 resolver 请继续"。
注意 handler 参数是 @Nullable 的:正常情况下是出异常的那个 Handler 对象,但如果异常发生在还没选中 Handler 的阶段(比如 multipart 解析失败),它就是 null。
2.2 DispatcherServlet 的三个默认 resolver
回顾(二)讲过的初始化流程,initStrategies() 会调用 initHandlerExceptionResolvers(context)。如果没有任何 resolver 被注册,会走 getDefaultStrategies() 兜底------从 DispatcherServlet.properties 里读默认实现类:
properties
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
这就是 SpringMVC 异常处理的默认三件套,顺序即优先级。各自的分工用表格整理:
| 顺序 | 解析器 | 职责 | 处理方式 |
|---|---|---|---|
| 1 | ExceptionHandlerExceptionResolver | 匹配 @ExceptionHandler 方法(本类 + @ControllerAdvice),日常开发的主角 |
反射调用异常处理方法,返回值复用(七)讲的整套返回值处理流程 |
| 2 | ResponseStatusExceptionResolver | 处理标了 @ResponseStatus 注解的异常类,以及 ResponseStatusException |
按注解/异常指定的状态码 sendError() |
| 3 | DefaultHandlerExceptionResolver | SpringMVC 标准异常(405、415、400、404 等) | 标准异常 → HTTP 状态码映射,sendError() |
再看到初始化的源码,这里藏着两个自定义入口:
java
private void initHandlerExceptionResolvers(ApplicationContext context) {
this.handlerExceptionResolvers = null;
if (this.detectAllHandlerExceptionResolvers) {
// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
// 默认开关打开:把容器里所有 HandlerExceptionResolver 类型的 bean 都收集起来
Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
// We keep HandlerExceptionResolvers in sorted order.
// 按 @Order / Ordered 排序,顺序决定优先级
AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
}
}
else {
// 开关关闭:只按固定 bean 名字取一个
try {
HandlerExceptionResolver her =
context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
this.handlerExceptionResolvers = Collections.singletonList(her);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, no HandlerExceptionResolver is fine too.
}
}
// Ensure we have at least some HandlerExceptionResolvers, by registering
// default HandlerExceptionResolvers if no other resolvers are found.
// 一个都没有注册时,才启用 properties 文件里的默认三件套
if (this.handlerExceptionResolvers == null) {
this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
两个值得注意的点:
- 只要容器里存在任意一个
HandlerExceptionResolver类型的 bean,默认三件套就不再生效 (detectAllHandlerExceptionResolvers默认为 true,收集所有实现类并按@Order排序)。不过不用担心把默认能力弄丢------SpringBoot 的WebMvcConfigurationSupport会把三件套连同我们的自定义 resolver 一起装配好,后面 3.6 节细说。 detectAllHandlerExceptionResolvers开关可以通过DispatcherServlet#setDetectAllHandlerExceptionResolvers(false)关掉,此时只认固定名字handlerExceptionResolver的那个 bean。
2.3 Composite 门面与类图
和参数解析、返回值处理一样,异常解析也有一个 Composite 门面。不过它比较特殊:DispatcherServlet 持有的直接就是 List<HandlerExceptionResolver>,Composite 只是作为其中一个普通成员出现在链表里(SpringBoot 自动装配时会用 Composite 把三件套打成一个包,顺序在第一位)。看一下它的核心逻辑:
java
/**
* Resolve the exception by iterating over the list of configured exception resolvers.
* <p>The first one to return a {@link ModelAndView} wins. Otherwise {@code null} is returned.
*/
@Override
@Nullable
public ModelAndView resolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
if (this.resolvers != null) {
for (HandlerExceptionResolver handlerExceptionResolver : this.resolvers) {
ModelAndView mav = handlerExceptionResolver.resolveException(request, response, handler, ex);
if (mav != null) {
return mav;
}
}
}
return null;
}
注释写得很直白:遍历委托,第一个返回非 null 的胜出 。和(七)的 selectHandler()、(六)的参数解析器选择,是同一个套路的第三次重复。
看一眼整体体系,一图胜千言:

除了 Composite 直接实现接口外,三个默认 resolver 都继承自 AbstractHandlerExceptionResolver------它用模板方法模式把流程固定为"先 shouldApplyTo() 判断这个 resolver 适不适用于当前请求和 handler,适用才调 doResolveException() 子类真干活"。ExceptionHandlerExceptionResolver 多垫了一层 AbstractHandlerMethodExceptionResolver,把适用范围限定为 HandlerMethod 类型。
三、源码解析过程
3.1 doDispatch 中的异常流转
回顾完体系,接下来看异常在 doDispatch() 里的完整流转。前面说过它是双层 try/catch,先看内层:
java
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
// 真正调用 Controller 方法(参数解析 + 返回值处理,前两篇讲过)
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.
// 4.3 起 Error 也会被处理:包成 ServletException(cause 保留原 Error)
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));
}
两个关键设计:
- 异常不在这里处理,而是先存起来 :
dispatchException = ex,然后无论正常还是异常路径,都汇合到processDispatchResult()统一善后。这样代码结构非常干净------ha.handle()抛异常后,applyPostHandle()自然被跳过(上一篇(八)讲的"异常时 postHandle 不执行"就是这么来的),直接进入善后流程。 - Error 也会被处理 :
catch (Throwable)分支把 Error 包成ServletException(cause 保留),这样@ExceptionHandler方法也有机会处理OutOfMemoryError之外的 Error。注意它会把异常塞进 cause,后面 3.3 节的 cause 链匹配会用到这一点。
紧接着看 processDispatchResult():
java
/**
* Handle the result of handler selection and handler invocation, which is
* either a ModelAndView or an Exception to be resolved to a ModelAndView.
*/
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) {
// 特例:这个异常自带 ModelAndView,直接取用,不走 resolver 链
logger.debug("ModelAndViewDefiningException encountered", exception);
mv = mavDefiningException.getModelAndView();
}
else {
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
// 异常处理的入口:交给 resolver 链解析成 ModelAndView
mv = processHandlerException(request, response, handler, exception);
errorView = (mv != null);
}
}
// Did the handler return a view to render?
// 解析成功的异常会产生"错误视图",走同一个 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..
// 注意:传 null------异常已经被处理完了,afterCompletion 回调不再携带异常
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
javadoc 一句话概括这个方法:"处理的结果要么是个 ModelAndView,要么是一个待解析成 ModelAndView 的 Exception"。除了常规的 resolver 链,还有一个特例分支:ModelAndViewDefiningException 自带 ModelAndView,直接取用,不用走 resolver。
最后是异常解析的核心 processHandlerException():
java
@Nullable
protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
@Nullable Object handler, Exception ex) throws Exception {
// Success and error responses may use different content types
// 清掉正常响应阶段留下的可产出类型标记,成功和错误响应的内容协商互不干扰
request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
// Reset the response content-type header and body buffer if the response is not committed already,
// leaving the other response headers in place.
try {
response.setHeader(HttpHeaders.CONTENT_TYPE, null);
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, null);
response.resetBuffer();
}
catch (IllegalStateException illegalStateException) {
// the response is already committed, leave it to exception handlers anyway
}
// Check registered HandlerExceptionResolvers...
// 按顺序遍历 resolver,第一个返回非 null 的胜出
ModelAndView exMv = null;
if (this.handlerExceptionResolvers != null) {
for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
exMv = resolver.resolveException(request, response, handler, ex);
if (exMv != null) {
break;
}
}
}
if (exMv != null) {
// 空 ModelAndView:异常已处理但无需渲染视图(比如只 sendError 了状态码)
if (exMv.isEmpty()) {
request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
return null;
}
// We might still need view name translation for a plain error model...
// ...(略)普通 model 还需要走一遍默认视图名翻译
if (logger.isTraceEnabled()) {
logger.trace("Using resolved error view: " + exMv, ex);
}
else if (logger.isDebugEnabled()) {
logger.debug("Using resolved error view: " + exMv);
}
// 把异常和堆栈放进 request 属性,错误视图里可以取用
WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
return exMv;
}
// 走到这说明没有任何 resolver 接手:把原异常重新抛出
throw ex;
}
这里的分支逻辑值得慢慢看:
- 空 ModelAndView 分支 :
exMv.isEmpty()说明"异常处理完了但不需要渲染视图"(典型场景:resolver 内部直接sendError()写了状态码,或者@ExceptionHandler返回 JSON 直接写响应体)。此时往 request 里放一个异常标记,返回 null------回到processDispatchResult()后mv == null,不渲染,走正常收尾。 - 非空 ModelAndView 分支 :解析出了错误视图,
exposeErrorRequestAttributes把异常信息放进 request 属性(JSP/Thymeleaf 错误页里能取到${exception}等),返回给render()渲染。 - 都没接手 →
throw ex:这是整个链的最后一环。异常被重新抛出,跳出processDispatchResult(),被doDispatch()外层 catch 捕获,触发triggerAfterCompletion()------上一篇文章说的"异常时 afterCompletion 仍会执行",指的就是这条路径,此时回调携带的是这个未被处理的异常。最终异常会一路抛到容器,由 Servlet 容器的 error page 机制兜底(SpringBoot 环境下则是被/error端点接管,渲染出默认 JSON 错误体)。
3.2 ExceptionHandlerExceptionResolver 的初始化
回顾完 DispatcherServlet 的流转,接下来看主角 ExceptionHandlerExceptionResolver。它实现了 InitializingBean------专栏(四)讲 RequestMappingHandlerAdapter 初始化时提过这个模式,容器启动回调 afterPropertiesSet():
java
@Override
public void afterPropertiesSet() {
// Do this first, it may add ResponseBodyAdvice beans
// 先初始化 @ControllerAdvice,其中会同时收集 ResponseBodyAdvice
initExceptionHandlerAdviceCache();
initMessageConverters();
if (this.argumentResolvers == null) {
List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
if (this.returnValueHandlers == null) {
List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
}
}
结构和(七)讲的 RequestMappingHandlerAdapter#afterPropertiesSet() 高度相似------毕竟"异常处理方法"本身也是一个 Handler 方法,一样需要参数解析器和返回值处理器。真正的新内容是 initExceptionHandlerAdviceCache():
java
private void initExceptionHandlerAdviceCache() {
if (getApplicationContext() == null) {
return;
}
// 找出容器里所有 @ControllerAdvice 标注的 bean
List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
for (ControllerAdviceBean adviceBean : adviceBeans) {
Class<?> beanType = adviceBean.getBeanType();
if (beanType == null) {
throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
}
// 为每个 advice bean 建一个 ExceptionHandlerMethodResolver,扫描其 @ExceptionHandler 方法
ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
if (resolver.hasExceptionMappings()) {
this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
}
if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
this.responseBodyAdvice.add(adviceBean);
}
}
if (logger.isDebugEnabled()) {
int handlerSize = this.exceptionHandlerAdviceCache.size();
int adviceSize = this.responseBodyAdvice.size();
if (handlerSize == 0 && adviceSize == 0) {
logger.debug("ControllerAdvice beans: none");
}
else {
logger.debug("ControllerAdvice beans: " +
handlerSize + " @ExceptionHandler, " + adviceSize + " ResponseBodyAdvice");
}
}
}
启动阶段就干一件事:把所有 @ControllerAdvice bean 提前扫一遍,每个 bean 配一个 ExceptionHandlerMethodResolver(封装了该类里所有 @ExceptionHandler 方法的映射表),存进 exceptionHandlerAdviceCache 。顺带还收集了 ResponseBodyAdvice------@ExceptionHandler 方法返回 JSON 时同样要过响应体增强链,这份 responseBodyAdvice 就是给它自己用的,与(七)里 RequestMappingHandlerAdapter 收集的那份并列。
除了 advice 缓存,还有另一个缓存字段:
java
private final Map<Class<?>, ExceptionHandlerMethodResolver> exceptionHandlerCache =
new ConcurrentHashMap<>(64);
private final Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> exceptionHandlerAdviceCache =
new LinkedHashMap<>();
两个缓存的分工:exceptionHandlerAdviceCache 是启动时初始化的全局 advice 缓存;exceptionHandlerCache 则是运行时按 Controller 类懒加载 的"本类 @ExceptionHandler 方法"缓存,首次遇到某 Controller 出异常时才扫描它的类结构,之后命中缓存。一个是全局(advice),一个是局部(Controller 类),3.3 节的匹配顺序马上要用到。
3.3 异常匹配规则
先看 ExceptionHandlerMethodResolver 的构造过程------它把一个类里所有 @ExceptionHandler 方法扫出来,建好"异常类型 → 方法"的映射表:
java
public ExceptionHandlerMethodResolver(Class<?> handlerType) {
// 找出该类(含父类)所有标注了 @ExceptionHandler 的方法
for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
ExceptionHandlerMappingInfo mappingInfo = detectExceptionMappings(method);
for (Class<? extends Throwable> exceptionType : mappingInfo.getExceptionTypes()) {
for (MediaType producibleType : mappingInfo.getProducibleTypes()) {
// 6.2 起:@ExceptionHandler(produces="application/json") 这类声明会按 异常类型+MediaType 建双重映射
addExceptionMapping(new ExceptionMapping(exceptionType, producibleType), mappingInfo);
}
if (mappingInfo.getProducibleTypes().isEmpty()) {
addExceptionMapping(new ExceptionMapping(exceptionType, MediaType.ALL), mappingInfo);
}
}
}
}
异常类型从哪来?看 detectExceptionMappings():
java
/**
* Extract exception mappings from the {@code @ExceptionHandler} annotation first,
* and then as a fallback from the method signature itself.
*/
@SuppressWarnings("unchecked")
private ExceptionHandlerMappingInfo detectExceptionMappings(Method method) {
ExceptionHandler exceptionHandler = readExceptionHandlerAnnotation(method);
// 优先取注解里声明的异常类型
List<Class<? extends Throwable>> exceptions = new ArrayList<>(Arrays.asList(exceptionHandler.exception()));
if (exceptions.isEmpty()) {
// 注解没写值时,兜底从方法参数里找 Throwable 类型
for (Class<?> paramType : method.getParameterTypes()) {
if (Throwable.class.isAssignableFrom(paramType)) {
exceptions.add((Class<? extends Throwable>) paramType);
}
}
}
if (exceptions.isEmpty()) {
throw new IllegalStateException("No exception types mapped to " + method);
}
// ...(略)解析注解 produces 属性为 MediaType 集合
return new ExceptionHandlerMappingInfo(Set.copyOf(exceptions), mediaTypes, method);
}
注解值优先,方法参数类型兜底 ------所以我们能写 @ExceptionHandler 不带 value、只靠方法参数上的异常类型来声明映射。两个都为空直接抛 IllegalStateException,启动期就报错,fail fast。
再看到匹配逻辑。请求时抛出的异常怎么从映射表里找出方法?入口是 resolveExceptionMapping():
java
@Nullable
public ExceptionHandlerMappingInfo resolveExceptionMapping(Throwable exception, MediaType mediaType) {
// 先按异常的本命类型匹配
ExceptionHandlerMappingInfo mappingInfo = resolveExceptionMappingByExceptionType(exception.getClass(), mediaType);
if (mappingInfo == null) {
// 本命类型没匹配上,顺着 cause 链往下递归
Throwable cause = exception.getCause();
if (cause != null) {
mappingInfo = resolveExceptionMapping(cause, mediaType);
}
}
return mappingInfo;
}
两层信息:一是 cause 链递归 ------包着 InvocationTargetException、ServletException 之类"壳异常"抛出来的场景,会剥开壳去匹配真正的业务异常;二是真正的匹配发生在 getMappedMethod():
java
@Nullable
private ExceptionHandlerMappingInfo getMappedMethod(Class<? extends Throwable> exceptionType, MediaType mediaType) {
// 找出所有声明类型 assignable(即能兼容)当前异常的映射
List<ExceptionMapping> matches = new ArrayList<>();
for (ExceptionMapping mappingInfo : this.mappedMethods.keySet()) {
if (mappingInfo.exceptionType().isAssignableFrom(exceptionType) && mappingInfo.mediaType().isCompatibleWith(mediaType)) {
matches.add(mappingInfo);
}
}
if (!matches.isEmpty()) {
// 多个命中时排序:异常类型距离最近者胜出
if (matches.size() > 1) {
matches.sort(new ExceptionMapingComparator(exceptionType, mediaType));
}
return this.mappedMethods.get(matches.get(0));
}
else {
// 没命中,返回哨兵对象(而不是 null),方便上层缓存"未匹配"结果
return NO_MATCHING_EXCEPTION_HANDLER;
}
}
三个重点:
- 匹配是"声明类型能兼容抛出类型" :
isAssignableFrom,所以@ExceptionHandler(RuntimeException.class)能接住NullPointerException。所有兼容的映射都算命中,然后排序。 - 异常距离最近者胜出 :排序用的是
ExceptionDepthComparator,它计算"声明的异常类型到实际抛出异常类型之间隔了几层继承",距离 0 最优。比如抛出ArithmeticException,同时存在@ExceptionHandler(ArithmeticException.class)和@ExceptionHandler(RuntimeException.class),前者的距离是 0、后者是 1,精确匹配永远胜过父类兜底 。这就是异常匹配的核心规则------不存在"方法级优先于类级"的说法,同一个类里所有@ExceptionHandler一视同仁,全靠异常距离分胜负;真正的"优先级分层"发生在 3.4 节的本类与全局之间。顺带一提,如果两个方法声明的异常类型完全相同,addExceptionMapping()在建表阶段就会抛IllegalStateException(Ambiguous @ExceptionHandler method mapped),避免歧义。 - NO_MATCHING_EXCEPTION_HANDLER 是个哨兵对象 :静态初始化块里把一个空方法包成
ExceptionHandlerMappingInfo常量。"没匹配到"的结果会以哨兵形式放进lookupCache(6.2 引入的ConcurrentLruCache,容量 24),避免每次请求都重复全表扫描,又不会像缓存 null 那样引入歧义。
另外 6.2 新增了 MediaType 维度:@ExceptionHandler(produces = "application/json") 可以限定异常处理方法只在特定 Accept 场景下生效,比较器在异常距离相同时还会进一步按 media type 的具体程度排序。日常开发用得少,知道有这回事即可。
3.4 找到方法后的调用
匹配到了 @ExceptionHandler 方法,接下来就是把异常交给它执行。回到 ExceptionHandlerExceptionResolver 的主流程:
java
@Override
@Nullable
protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
// 第一步:找到异常处理方法(找不到直接返回 null,让链上下一个 resolver 接手)
ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception, webRequest);
if (exceptionHandlerMethod == null) {
return null;
}
// 第二步:把本 resolver 持有的参数解析器、返回值处理器装配给异常处理方法
// ------ 异常处理方法的返回值(JSON/视图名/ResponseEntity)复用(七)讲的整套处理流程
if (this.argumentResolvers != null) {
exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
}
if (this.returnValueHandlers != null) {
exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
}
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
ArrayList<Throwable> exceptions = new ArrayList<>();
try {
if (logger.isDebugEnabled()) {
logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
}
// Expose causes as provided arguments as well
// 把异常本体 + 整条 cause 链都收集起来,作为"额外参数"传给异常处理方法
Throwable exToExpose = exception;
while (exToExpose != null) {
exceptions.add(exToExpose);
Throwable cause = exToExpose.getCause();
exToExpose = (cause != exToExpose ? cause : null);
}
Object[] arguments = new Object[exceptions.size() + 1];
exceptions.toArray(arguments); // efficient arraycopy call in ArrayList
arguments[arguments.length - 1] = handlerMethod;
// 第三步:反射调用。这就是(七)贴过的同一个 invokeAndHandle()
exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, arguments);
}
catch (Throwable invocationEx) {
if (disconnectedClientHelper.checkAndLogClientDisconnectedException(invocationEx)) {
return new ModelAndView();
}
// Any other than the original exception (or a cause) is unintended here,
// probably an accident (for example, failed assertion or the like).
if (!exceptions.contains(invocationEx) && logger.isWarnEnabled()) {
logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
}
// Continue with default processing of the original exception...
// 异常处理方法自己炸了:返回 null,退回默认处理链
return null;
}
// 第四步:根据返回值处理结果构造 ModelAndView
if (mavContainer.isRequestHandled()) {
// @ExceptionHandler 返回 JSON(requestHandled=true):返回空 ModelAndView,表示已处理完
return new ModelAndView();
}
else {
ModelMap model = mavContainer.getModel();
HttpStatusCode status = mavContainer.getStatus();
// 返回视图名/ModelAndView:包成错误 ModelAndView 交给 render() 渲染
ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
mav.setViewName(mavContainer.getViewName());
if (!mavContainer.isViewReference()) {
mav.setView((View) mavContainer.getView());
}
if (model instanceof RedirectAttributes redirectAttributes) {
Map<String, ?> flashAttributes = redirectAttributes.getFlashAttributes();
RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
}
return mav;
}
}
这段是整个异常处理体系的核心,串起来讲:
- 异常处理方法的参数注入 :
invokeAndHandle()的可变参数providedArgs传入了异常本体、整条 cause 链、出异常的HandlerMethod。所以@ExceptionHandler方法可以灵活声明参数:(NullPointerException ex)、(Exception ex, HandlerMethod handlerMethod)都能注入------参数解析器((六)讲的HandlerMethodArgumentResolver体系)负责匹配,providedArgs 是兜底来源。 - 返回值处理完全复用(七)的流程 :
@ExceptionHandler返回Map/对象 +@ResponseBody就走RequestResponseBodyMethodProcessor写 JSON;返回String就走ViewNameMethodReturnValueHandler变成错误视图名;返回ResponseEntity就走HttpEntityMethodProcessor。一切和普通 Controller 方法无异。 mavContainer.isRequestHandled()是分水岭 :返回 JSON 时标志位被置 true → 返回空 ModelAndView → 回到 3.1 节processHandlerException()的exMv.isEmpty()分支 → 不渲染视图,请求结束;返回视图名 → 返回带视图的 ModelAndView →render()渲染错误页面。- 异常处理方法自己抛异常 :只要抛的不是原异常链上的东西(说明是处理逻辑自身出了 bug),就打 warn 日志并返回 null------原异常退回 resolver 链,继续给后面的
ResponseStatusExceptionResolver/DefaultHandlerExceptionResolver走默认映射,而不是让新异常顶替原异常。
完整的调用过程用时序图表示(以最常见的"返回 JSON"场景为例):

最后补一下 getExceptionHandlerMethod() 的查找顺序,源码里有两个清晰的阶段:
java
@Nullable
protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
@Nullable HandlerMethod handlerMethod, Exception exception, ServletWebRequest webRequest) {
// ...(略)先按 Accept 头解析出 acceptedMediaTypes
Class<?> handlerType = null;
if (handlerMethod != null) {
// Local exception handler methods on the controller class itself.
// 阶段一:先找出 Controller 自己类上的 @ExceptionHandler(懒加载进 exceptionHandlerCache)
handlerType = handlerMethod.getBeanType();
ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.computeIfAbsent(
handlerType, ExceptionHandlerMethodResolver::new);
for (MediaType mediaType : acceptedMediaTypes) {
ExceptionHandlerMappingInfo mappingInfo = resolver.resolveExceptionMapping(exception, mediaType);
if (mappingInfo != null) {
// ...(略)命中则记录 producibleTypes 并返回
return new ServletInvocableHandlerMethod(handlerMethod.getBean(), mappingInfo.getHandlerMethod(), this.applicationContext);
}
}
// ...(略)AOP 代理类换成目标类
}
// 阶段二:本类没找到,遍历 @ControllerAdvice 缓存
for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
ControllerAdviceBean advice = entry.getKey();
// @ControllerAdvice 可用 basePackages / assignableTypes 限定作用范围
if (advice.isApplicableToBeanType(handlerType)) {
ExceptionHandlerMethodResolver resolver = entry.getValue();
for (MediaType mediaType : acceptedMediaTypes) {
ExceptionHandlerMappingInfo mappingInfo = resolver.resolveExceptionMapping(exception, mediaType);
if (mappingInfo != null) {
// ...(略)同上
return new ServletInvocableHandlerMethod(advice.resolveBean(), mappingInfo.getHandlerMethod(), this.applicationContext);
}
}
}
}
return null;
}
规则一句话:本类 @ExceptionHandler 优先于 @ControllerAdvice 全局 ,本类没命中才去问 advice;advice 缓存按注册顺序遍历,isApplicableToBeanType 负责 @ControllerAdvice(basePackages = ...) 这类范围限定。
3.5 DefaultHandlerExceptionResolver 与 ResponseStatusExceptionResolver
主角讲完,再看到链上的另外两位。DefaultHandlerExceptionResolver 负责把 SpringMVC 的标准异常翻译成 HTTP 状态码,javadoc 里自带一张映射表,挑最常用的整理如下:
| 异常 | HTTP 状态码 |
|---|---|
| HttpRequestMethodNotSupportedException | 405 |
| HttpMediaTypeNotSupportedException | 415 |
| HttpMediaTypeNotAcceptableException | 406 |
| MissingServletRequestParameterException | 400 |
| MethodArgumentNotValidException | 400 |
| HttpMessageNotReadableException | 400 |
| TypeMismatchException | 400 |
| NoHandlerFoundException / NoResourceFoundException | 404 |
| AsyncRequestTimeoutException | 503 |
| ConversionNotSupportedException / HttpMessageNotWritableException | 500 |
看它的 doResolveException() 主干(6.2 里标准异常都实现了 ErrorResponse 接口,走统一出口):
java
@Override
@Nullable
protected ModelAndView doResolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
try {
// ErrorResponse exceptions that expose HTTP response details
// 6.0 起多数标准异常实现了 ErrorResponse 接口,统一走这个分支
if (ex instanceof ErrorResponse errorResponse) {
ModelAndView mav = null;
if (ex instanceof HttpRequestMethodNotSupportedException theEx) {
mav = handleHttpRequestMethodNotSupported(theEx, request, response, handler);
}
else if (ex instanceof HttpMediaTypeNotSupportedException theEx) {
mav = handleHttpMediaTypeNotSupported(theEx, request, response, handler);
}
// ...(略)其余标准异常分支同构,略
return (mav != null ? mav :
handleErrorResponse(errorResponse, request, response, handler));
}
// Other, lower level exceptions
// 没实现 ErrorResponse 的老异常,各自处理
if (ex instanceof ConversionNotSupportedException theEx) {
return handleConversionNotSupported(theEx, request, response, handler);
}
else if (ex instanceof TypeMismatchException theEx) {
return handleTypeMismatch(theEx, request, response, handler);
}
else if (ex instanceof HttpMessageNotReadableException theEx) {
return handleHttpMessageNotReadable(theEx, request, response, handler);
}
else if (ex instanceof HttpMessageNotWritableException theEx) {
return handleHttpMessageNotWritable(theEx, request, response, handler);
}
// ...(略)MethodValidationException、客户端断连等分支
}
catch (Exception handlerEx) {
// ...(略)解析过程自己出异常只打 warn
}
return null;
}
注意每个 handleXxx 默认都返回 null(留给子类覆盖),最终汇到 handleErrorResponse() 统一处理------它就是 3.1 节说的"空 ModelAndView"的典型产地:
java
protected ModelAndView handleErrorResponse(ErrorResponse errorResponse,
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) throws IOException {
if (!response.isCommitted()) {
// 把 ErrorResponse 携带的响应头写出去
HttpHeaders headers = errorResponse.getHeaders();
headers.forEach((name, values) -> values.forEach(value -> response.addHeader(name, value)));
int status = errorResponse.getStatusCode().value();
String message = errorResponse.getBody().getDetail();
if (message != null) {
response.sendError(status, message);
}
else {
response.sendError(status);
}
}
else if (logger.isWarnEnabled()) {
logger.warn("Ignoring exception, response committed already: " + errorResponse);
}
return new ModelAndView();
}
sendError() 设置状态码后返回空 ModelAndView ------异常算"处理完了",但不渲染视图;SpringBoot 环境下容器会把请求转发给 /error 端点,渲染出我们熟悉的默认 JSON 错误体。所以你在 Boot 里看到的 405/400/415 的 JSON body,其实是这条链 + Boot 的 BasicErrorController 共同完成的。
ResponseStatusExceptionResolver 则负责"声明式状态码" ------异常类上标 @ResponseStatus 注解,或者直接抛 ResponseStatusException:
java
@Override
@Nullable
protected ModelAndView doResolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
try {
if (ex instanceof ResponseStatusException rse) {
// 分支一:直接抛 ResponseStatusException,状态码和 reason 在异常对象里
return resolveResponseStatusException(rse, request, response, handler);
}
// 分支二:异常类上找 @ResponseStatus 注解(支持查找元注解)
ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(ex.getClass(), ResponseStatus.class);
if (status != null) {
return resolveResponseStatus(status, request, response, handler, ex);
}
if (ex.getCause() instanceof Exception cause) {
// 分支三:本异常没标注解,顺着 cause 链继续找
return doResolveException(request, response, handler, cause);
}
}
catch (Exception resolveEx) {
// ...(略)
}
return null;
}
三个分支逻辑清晰:ResponseStatusException 优先、注解次之、cause 链递归兜底。最终都汇到 applyStatusAndReason():
java
protected ModelAndView applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response)
throws IOException {
if (!StringUtils.hasLength(reason)) {
// 没有 reason:只设置状态码
response.sendError(statusCode);
}
else {
// 有 reason:先过一遍 MessageSource 国际化解析,再带 reason 发出错误
String resolvedReason = (this.messageSource != null ?
this.messageSource.getMessage(reason, null, reason, LocaleContextHolder.getLocale()) :
reason);
response.sendError(statusCode, resolvedReason);
}
return new ModelAndView();
}
同样是 sendError() + 空 ModelAndView。顺带能看到 reason 支持国际化------如果它命中 MessageSource 里的 key,会被替换成对应 locale 的文案。
3.6 自定义的三种方式与优先级
体系讲完,看实战里我们怎么扩展。常用方式三种:
方式一:本类 @ExceptionHandler。作用域仅限当前 Controller,能访问类内状态,优先级最高:
java
@RestController
@RequestMapping("/order")
public class OrderController {
@ExceptionHandler(OrderNotFoundException.class)
public Map<String, Object> handleNotFound(OrderNotFoundException ex) {
return Map.of("code", 40401, "message", ex.getMessage());
}
}
方式二:@ControllerAdvice 全局异常处理 。作用域默认全局,配合 @RestControllerAdvice 可以直接返回 JSON;可以用 basePackages、assignableTypes 等属性限定生效范围:
java
@RestControllerAdvice
public class GlobalExceptionHandlerAdvice {
@ExceptionHandler(BizException.class)
public Map<String, Object> handleBiz(BizException ex) {
return Map.of("code", ex.getCode(), "message", ex.getMessage());
}
}
方式三:实现 HandlerExceptionResolver 接口。这是最底层的扩展点,拿到的就是原始的 request/response/handler/ex 四件套,自由度最大,但要自己写响应:
java
public class CustomExceptionResolver implements HandlerExceptionResolver, Ordered {
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
if (ex instanceof NotSupportedException nse) {
response.setContentType("text/plain;charset=UTF-8");
try {
response.getWriter().write("自定义 resolver 接管:" + nse.getMessage());
}
catch (IOException ignored) {
}
return new ModelAndView(); // 空 ModelAndView 表示已处理
}
return null; // 不归我管,交给下一个 resolver
}
@Override
public int getOrder() {
return Ordered.LOWEST_PRECEDENCE;
}
}
注册走 WebMvcConfigurer,注意两个回调的区别:
java
@Configuration
public class CustomWebConfig implements WebMvcConfigurer {
@Override
public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
// 推荐:保留默认三件套,把自己的 resolver 追加到链尾(或按 order 排序)
resolvers.add(new CustomExceptionResolver());
}
}
如果用的是 configureHandlerExceptionResolvers()(不推荐),默认三件套会被完全替换 ------@ControllerAdvice、405/400 状态码映射全部失效,这是很多人踩过的坑。另外由于自定义实现类是普通 bean,detectAllHandlerExceptionResolvers 的收集逻辑同样能发现它,@Order 值决定它插在链上什么位置。
最后把整条链的优先级整理成表:
| 优先级 | 组件 | 说明 |
|---|---|---|
| 1 | 本类 @ExceptionHandler |
getExceptionHandlerMethod() 先查 exceptionHandlerCache |
| 2 | @ControllerAdvice 全局 |
本类没命中才查 exceptionHandlerAdviceCache |
| 3 | @ResponseStatus 注解异常 |
ExceptionHandlerExceptionResolver 都没接手时才轮到 ResponseStatusExceptionResolver |
| 4 | 标准异常状态码映射 | 最后轮到 DefaultHandlerExceptionResolver |
| 5 | 无人处理 → throw ex |
走容器 error page / Boot /error 端点 |
一句话记忆:越精确、越靠近业务代码的处理器优先级越高;声明式的兜底(注解状态码、标准异常映射)排在其后;全都失败才让容器收拾残局。
四、Demo 实战验证
以上所有场景整理成一个可运行的 SpringBoot 3.4.5 工程(文末有完整代��地址),Controller 关键代码如下:
java
@RestController
@RequestMapping("/order")
public class OrderController {
// 场景一:本类 @ExceptionHandler
@GetMapping("/local-npe")
public String localNpe() {
throw new NullPointerException("订单对象为空"); // NPE 属于 RuntimeException,命中本类兜底
}
// 场景二:异常距离验证。抛 ArithmeticException 时,
// handleArithmetic 距离 0、handleRuntime 距离 1,精确匹配胜出
@GetMapping("/div")
public String div() {
int i = 1 / 0;
return "never reach here";
}
@ExceptionHandler(ArithmeticException.class)
public Map<String, Object> handleArithmetic(ArithmeticException ex) {
return Map.of("from", "OrderController#handleArithmetic", "message", "除零啦");
}
@ExceptionHandler(RuntimeException.class)
public Map<String, Object> handleRuntime(RuntimeException ex) {
return Map.of("from", "OrderController#handleRuntime", "message", ex.getMessage());
}
// 场景三:无人接手的异常(受检异常,本类与 advice 都没有匹配)
@GetMapping("/uncaught")
public String uncaught() throws GeneralFailureException {
throw new GeneralFailureException("无人接手");
}
// 场景四:缺必填参数 → MissingServletRequestParameterException
@GetMapping("/missing-param")
public String missingParam(@RequestParam Long id) {
return "id=" + id;
}
// 场景五:请求方式不对(GET 端点收 POST)→ HttpRequestMethodNotSupportedException
@GetMapping("/method")
public String method() {
return "only GET";
}
}
全局 advice 与两个注解异常:
java
// @ControllerAdvice 全局:本类没命中时才轮到它
@RestControllerAdvice
public class GlobalExceptionHandlerAdvice {
@ExceptionHandler(BizException.class)
public Map<String, Object> handleBiz(BizException ex) {
return Map.of("from", "GlobalExceptionHandlerAdvice", "code", ex.getCode(), "message", ex.getMessage());
}
}
// @ResponseStatus 声明式状态码
@ResponseStatus(code = HttpStatus.TOO_MANY_REQUESTS, reason = "请求太频繁")
public class TooManyRequestsException extends RuntimeException {
}
// 自定义 resolver 负责的异常
public class NotSupportedException extends RuntimeException {
public NotSupportedException(String message) { super(message); }
}
自定义 resolver 与注册:
java
public class CustomExceptionResolver implements HandlerExceptionResolver, Ordered {
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
if (ex instanceof NotSupportedException nse) {
response.setContentType("text/plain;charset=UTF-8");
try {
response.getWriter().write("自定义 resolver 接管:" + nse.getMessage());
}
catch (IOException ignored) {
}
return new ModelAndView();
}
return null;
}
@Override
public int getOrder() {
return Ordered.LOWEST_PRECEDENCE;
}
}
@Configuration
public class CustomWebConfig implements WebMvcConfigurer {
@Override
public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
resolvers.add(new CustomExceptionResolver());
}
}
启动后逐个请求验证,结果与源码分析完全对应:
| 请求 | 抛出的异常 | 接手的组件 | 实际响应 |
|---|---|---|---|
| GET /order/local-npe | NullPointerException | 本类 handleRuntime(异常距离 1,本类优先) | 200 JSON {"from":"OrderController#handleRuntime",...} |
| GET /order/div | ArithmeticException | 本类 handleArithmetic(距离 0 击败距离 1) | 200 JSON {"from":"OrderController#handleArithmetic",...} |
| GET /order/global | BizException(本类无匹配) | @ControllerAdvice 全局 advice |
200 JSON 统一结构 |
| GET /order/uncaught | GeneralFailureException(受检异常) | 三个默认 resolver 都不接手,throw ex |
500 + Boot /error 默认错误 JSON |
| GET /order/status | TooManyRequestsException(@ResponseStatus) |
ResponseStatusExceptionResolver | 429 + Boot /error 默认错误 JSON |
| GET /order/rse | new ResponseStatusException(BAD_REQUEST, "参数不合法") |
ResponseStatusExceptionResolver | 400 + Boot 默认错误 JSON |
| GET /order/missing-param(不带参数) | MissingServletRequestParameterException | DefaultHandlerExceptionResolver | 400 |
| POST /order/method | HttpRequestMethodNotSupportedException | DefaultHandlerExceptionResolver | 405 |
| GET /order/custom | NotSupportedException(前三个都不认识) | 自定义 CustomExceptionResolver | 200 text/plain |
两个容易疑惑的点说明一下:/order/local-npe 虽然同时能被全局 advice 兜住,但本类方法优先 ,全局 advice 根本轮不到;/order/status 这类走 sendError() 的响应,body 由 Boot 的 /error 端点渲染------resolver 只负责定状态码。
最后用一张图把本文的知识点归纳一下:

五、总结
异常处理由 DispatcherServlet 在 doDispatch() 内层 catch 统一收集,交给 processHandlerException() 按顺序遍历 HandlerExceptionResolver 链:@ExceptionHandler 体系(本类方法优先于 @ControllerAdvice,异常距离最近者胜出)排第一,@ResponseStatus 声明式状态码和标准异常映射殿后,返回值复用整套返回值处理流程,谁都接不住就 throw ex 交还容器。
下一篇我们分析 doDispatch() 之外、贯穿参数与异常两篇的底层能力------数据绑定与类型转换,看看 WebDataBinder、Converter 体系是怎么把请求参数变成方法入参的。
Demo 完整代码 :SpringMVC/09-异常处理/exception-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+源码分析(六)参数处理
- SpringMVC 6+源码分析(七)返回值处理
- SpringMVC 6+源码分析(八)拦截器
本文为「源码学习」专栏系列文章,转载请注明出处。相互学习,共同进步!