SpringMVC 6+源码分析(九)异常处理

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");
			}
		}
	}

两个值得注意的点:

  1. 只要容器里存在任意一个 HandlerExceptionResolver 类型的 bean,默认三件套就不再生效 (detectAllHandlerExceptionResolvers 默认为 true,收集所有实现类并按 @Order 排序)。不过不用担心把默认能力弄丢------SpringBoot 的 WebMvcConfigurationSupport 会把三件套连同我们的自定义 resolver 一起装配好,后面 3.6 节细说。
  2. 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;
		}
	}

三个重点:

  1. 匹配是"声明类型能兼容抛出类型" :isAssignableFrom,所以 @ExceptionHandler(RuntimeException.class) 能接住 NullPointerException。所有兼容的映射都算命中,然后排序。
  2. 异常距离最近者胜出 :排序用的是 ExceptionDepthComparator,它计算"声明的异常类型到实际抛出异常类型之间隔了几层继承",距离 0 最优。比如抛出 ArithmeticException,同时存在 @ExceptionHandler(ArithmeticException.class) 和 @ExceptionHandler(RuntimeException.class),前者的距离是 0、后者是 1,精确匹配永远胜过父类兜底 。这就是异常匹配的核心规则------不存在"方法级优先于类级"的说法,同一个类里所有 @ExceptionHandler 一视同仁,全靠异常距离分胜负;真正的"优先级分层"发生在 3.4 节的本类与全局之间。顺带一提,如果两个方法声明的异常类型完全相同,addExceptionMapping() 在建表阶段就会抛 IllegalStateException(Ambiguous @ExceptionHandler method mapped),避免歧义。
  3. 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 启动后按上表逐个请求验证)

专栏往期:

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

相关推荐
geats人山人海16 分钟前
现代c++4.1
java·开发语言·c++
下一站春风里1 小时前
Spring IoC 控制反转 完整技术笔记
java·spring boot·笔记·spring
挖掘狂人1 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·后端·面试
codigger1 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·程序员·支付·java后端
Resean02231 小时前
SpringMVC 6+源码分析(十)数据绑定与类型转换
java·spring·springmvc
lw_zhang11012 小时前
爆肝一个月,Java 从入门到精通39 - 使用Log4j
java·单元测试·log4j
Rain的Java大神之路2 小时前
面试官问"MySQL 大表 COUNT(*) 怎么优化",90% 的人第一步就答错了
java·后端·面试
唐老板2 小时前
AI 都会编程了,Java 何去何从
java·ai编程
nice_lcj5202 小时前
MySQL 慢查询与 EXPLAIN:怎么定位、怎么优化
java·数据库·后端·mysql