Spring MVC 源码- HandlerExceptionResolver 组件

HandlerExceptionResolver 组件

HandlerExceptionResolver 组件，处理器异常解析器，将处理器（ handler ）执行时发生的异常（也就是处理请求，执行方法的过程中）解析（转换）成对应的 ModelAndView 结果

回顾

先来回顾一下在 DispatcherServlet 中处理请求的过程中哪里使用到 HandlerExceptionResolver 组件，可以回到《一个请求响应的旅行过程》中的 DispatcherServlet 的 processHandlerException 方法中看看，如下：

@Nullable
protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,@Nullable Object handler, Exception ex) throws Exception {// Success and error responses may use different content types// 移除 PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE 属性request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);// Check registered HandlerExceptionResolvers...// <a> 遍历 HandlerExceptionResolver 数组，解析异常，生成 ModelAndView 对象ModelAndView exMv = null;if (this.handlerExceptionResolvers != null) {// 遍历 HandlerExceptionResolver 数组for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {// 解析异常，生成 ModelAndView 对象exMv = resolver.resolveException(request, response, handler, ex);// 生成成功，结束循环if (exMv != null) {break;}}}// <b> 情况一，生成了 ModelAndView 对象，进行返回if (exMv != null) {// ModelAndView 对象为空，则返回 nullif (exMv.isEmpty()) {request.setAttribute(EXCEPTION_ATTRIBUTE, ex);return null;}// We might still need view name translation for a plain error model...// 没有视图则设置默认视图if (!exMv.hasView()) {String defaultViewName = getDefaultViewName(request);if (defaultViewName != null) {exMv.setViewName(defaultViewName);}}// 设置请求中的错误消息属性WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());return exMv;}// <c> 情况二，未生成 ModelAndView 对象，则抛出异常throw ex;
}

在 Spring MVC 的 DispatcherServlet 处理请求执行方法过程中，不管是否抛出异常都会进行结果处理，如果抛出了异常也需要调用该方法处理异常

可以看到，在 <a> 处会遍历所有的 HandlerExceptionResolver 异常处理器来处理，如果某一个处理器处理成功并返回 ModelAndView 对象，则直接返回

HandlerExceptionResolver 接口

org.springframework.web.servlet.HandlerExceptionResolver，异常处理器接口，代码如下：

public interface HandlerExceptionResolver {/*** 解析异常，转换成对应的 ModelAndView 结果*/@NullableModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
}

HandlerExceptionResolver 接口体系的结构如下：

初始化过程

在 DispatcherServlet 的 initHandlerExceptionResolvers(ApplicationContext context) 方法，初始化 HandlerExceptionResolver 组件，方法如下：

private void initHandlerExceptionResolvers(ApplicationContext context) {// 置空 handlerExceptionResolvers 处理this.handlerExceptionResolvers = null;// 情况一，自动扫描 HandlerExceptionResolver 类型的 Bean 们if (this.detectAllHandlerExceptionResolvers) {// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.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.AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);}}// 情况二，获得名字为 HANDLER_EXCEPTION_RESOLVER_BEAN_NAME 的 Beanelse {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./*** 情况三，如果未获得到，则获得默认配置的 HandlerExceptionResolver 类* {@link org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver}* {@link    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver}* {@link    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver}*/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 们，添加到 handlerExceptionResolvers 中，默认开启

如果“关闭”探测功能，则获得 Bean 名称为 "handlerExceptionResolver" 对应的 Bean ，将其添加至 handlerExceptionResolvers

如果未获得到，则获得默认配置的 HandlerExceptionResolver 类，调用 getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) 方法，就是从 DispatcherServlet.properties 文件中读取 HandlerExceptionResolver 的默认实现类，如下：

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

在 Spring Boot 中，默认配置下会走上述 1 的逻辑，handlerExceptionResolvers 有两个元素：

org.springframework.boot.autoconfigure.web.DefaultErrorAttributes：在 Spring Boot 中，逻辑比较简单，暂时忽略

org.springframework.web.servlet.handler.HandlerExceptionResolverComposite：复合的 HandlerExceptionResolver 实现类

接下来会对 HandlerExceptionResolverComposite 中的这三种异常处理器进行分析

HandlerExceptionResolverComposite

org.springframework.web.servlet.handler.HandlerExceptionResolverComposite，实现 HandlerExceptionResolver、Ordered 接口，复合的 HandlerExceptionResolver 实现类

构造方法

public class HandlerExceptionResolverComposite implements HandlerExceptionResolver, Ordered {/*** 异常解析器数组*/@Nullableprivate List<HandlerExceptionResolver> resolvers;/*** 优先级，默认最低*/private int order = Ordered.LOWEST_PRECEDENCE;
}

resolvers：HandlerExceptionResolver 实现类列表

order：优先级，默认最低

从上面的初始化过程中可以看到，Spring Boot 默认配置下 HandlerExceptionResolverComposite 包含三个实现类：

org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver

org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver

org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

resolveException

实现 resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) 方法，遍历 HandlerExceptionResolver 数组，逐个处理异常 ex，如果成功，则返回 ModelAndView 对象，方法如下：

@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;
}

AbstractHandlerExceptionResolver

org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver，实现 HandlerExceptionResolver、Ordered 接口，HandlerExceptionResolver 抽象类，作为所有 HandlerExceptionResolver 实现类的基类

构造方法

public abstract class AbstractHandlerExceptionResolver implements HandlerExceptionResolver, Ordered {private static final String HEADER_CACHE_CONTROL = "Cache-Control";/*** 优先级，默认最低*/private int order = Ordered.LOWEST_PRECEDENCE;/*** 匹配的处理器对象的集合*/@Nullableprivate Set<?> mappedHandlers;/*** 匹配的处理器类型的数组*/@Nullableprivate Class<?>[] mappedHandlerClasses;/*** 防止响应缓存*/private boolean preventResponseCaching = false;
}

上面的这些属性在后续方法中会讲到

shouldApplyTo

shouldApplyTo(HttpServletRequest request, Object handler) 方法，判断当前 HandlerExceptionResolver 是否能应用到传入的 handler 处理器，方法如下：

protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {if (handler != null) {// <1> 如果 mappedHandlers 包含 handler 对象，则返回 trueif (this.mappedHandlers != null && this.mappedHandlers.contains(handler)) {return true;}// <2> 如果 mappedHandlerClasses 包含 handler 的类型，则返回 trueif (this.mappedHandlerClasses != null) {for (Class<?> handlerClass : this.mappedHandlerClasses) {if (handlerClass.isInstance(handler)) {return true;}}}}// Else only apply if there are no explicit handler mappings.// <3> 如果 mappedHandlers 和 mappedHandlerClasses 都为空，说明直接匹配return (this.mappedHandlers == null && this.mappedHandlerClasses == null);
}

如果 mappedHandlers 包含该 handler 处理器对象，则返回 true

如果 mappedHandlerClasses 包含该 handler 处理器所在类，则返回 true

如果 mappedHandlers 和 mappedHandlerClasses 都为空，说明直接匹配

prepareResponse

prepareResponse(Exception ex, HttpServletResponse response) 方法，阻止响应缓存，方法如下：

protected void prepareResponse(Exception ex, HttpServletResponse response) {if (this.preventResponseCaching) {preventCaching(response);}
}/*** Prevents the response from being cached, through setting corresponding* HTTP {@code Cache-Control: no-store} header.* @param response current HTTP response*/
protected void preventCaching(HttpServletResponse response) {response.addHeader(HEADER_CACHE_CONTROL, "no-store");
}

如果想要阻止响应缓存，需要设置 preventResponseCaching 为 true

resolveException

实现 resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 方法，代码如下

@Override
@Nullable
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {// <1> 判断是否可以应用if (shouldApplyTo(request, handler)) {// <1.1> 阻止缓存prepareResponse(ex, response);// <1.2> 执行解析异常，返回 ModelAndView 对象ModelAndView result = doResolveException(request, response, handler, ex);// <1.3> 如果 ModelAndView 对象非空，则打印日志if (result != null) {// Print debug message when warn logger is not enabled.if (logger.isDebugEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {logger.debug("Resolved [" + ex + "]" + (result.isEmpty() ? "" : " to " + result));}// Explicitly configured warn logger in logException method.logException(ex, request);}// <1.4> 返回执行结果return result;}// <2> 不可应用，直接返回 nullelse {return null;}
}@Nullable
protected abstract ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);

调用 shouldApplyTo(HttpServletRequest request, Object handler) 方法，判断是否可以应用，如果可以应用

调用 prepareResponse(Exception ex, HttpServletResponse response) 方法，阻止缓存

调用 doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) 抽象方法，执行解析异常，返回 ModelAndView 对象

如果 ModelAndView 对象非空，则打印日志

返回执行结果

不可应用，直接返回 null

AbstractHandlerMethodExceptionResolver

org.springframework.web.servlet.handler.AbstractHandlerMethodExceptionResolver，继承 AbstractHandlerExceptionResolver 抽象类，基于 handler 类型为 HandlerMethod 的 HandlerExceptionResolver 抽象类。

可能你会有疑惑，为什么 AbstractHandlerMethodExceptionResolver 只有一个 ExceptionHandlerExceptionResolver 子类，为什么还要做抽象呢？因为 ExceptionHandlerExceptionResolver 是基于 @ExceptionHandler 注解来配置对应的异常处理器，而如果未来我们想自定义其它的方式来配置对应的异常处理器，就可以来继承（拓展性）AbstractHandlerMethodExceptionResolver 这个抽象类。

有没发现 Spring MVC 中，存在大量的逻辑与配置分离的分层实现

shouldApplyTo

重写 shouldApplyTo(HttpServletRequest request, Object handler) 方法，代码如下：

@Override
protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {// 情况一，如果 handler 为空，则直接调用父方法if (handler == null) {return super.shouldApplyTo(request, null);}// 情况二，处理 handler 为 HandlerMethod 类型的情况else if (handler instanceof HandlerMethod) {// <x> 获得真正的 handlerHandlerMethod handlerMethod = (HandlerMethod) handler;handler = handlerMethod.getBean();// 调用父方法return super.shouldApplyTo(request, handler);}// 情况三，直接返回 falseelse {return false;}
}

重点在于情况二，需要在 <x> 处，调用 HandlerMethod#getBean() 方法，获得真正的 handler 处理器。

doResolveException

重写 doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 方法，代码如下：

@Override
@Nullable
protected final ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {return doResolveHandlerMethodException(request, response, (HandlerMethod) handler, ex);
}@Nullable
protected abstract ModelAndView doResolveHandlerMethodException(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception ex);

将 handler 转换成 HandlerMethod 类型，并提供新的抽象方法

【重点】ExceptionHandlerExceptionResolver

org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver，实现 ApplicationContextAware、InitializingBean 接口，继承 AbstractHandlerMethodExceptionResolver 抽象类，基于 @ExceptionHandler 配置 HandlerMethod 的 HandlerExceptionResolver 实现类。

示例

可能你没有使用 @ExceptionHandler 注解来实现过异常的处理，例如：

@Log4j2
@RestControllerAdvice
public class CustomizeExceptionHandler extends ResponseEntityExceptionHandler {@ExceptionHandler({EmptyArgumentException.class, IllegalArgumentException.class})public Result<?> customizeHandleArgumentException(HttpServletRequest request, final Exception e, HttpServletResponse response) {response.setStatus(HttpStatus.OK.value());return Result.fail(ResultCode.PARAM_ERROR.getCode(), e.getMessage());}@ExceptionHandler({Exception.class})public Result<?> customizeHandleException(HttpServletRequest request, final Exception e, HttpServletResponse response) {log.error("异常拦截[{}]：", e.getMessage(), e);response.setStatus(HttpStatus.OK.value());return Result.fail(ResultCode.UNKNOWN.getCode(), e.getMessage());}
}

该自定义异常处理类会处理 Controller 类抛出的指定类型的异常

构造方法

public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolverimplements ApplicationContextAware, InitializingBean {/*** 自定义的方法参数处理器*/@Nullableprivate List<HandlerMethodArgumentResolver> customArgumentResolvers;/*** 方法参数处理器组合*/@Nullableprivate HandlerMethodArgumentResolverComposite argumentResolvers;/*** 自定义的执行结果处理器*/@Nullableprivate List<HandlerMethodReturnValueHandler> customReturnValueHandlers;/*** 执行结果处理器组合*/@Nullableprivate HandlerMethodReturnValueHandlerComposite returnValueHandlers;/** HTTP 消息转换器*/private List<HttpMessageConverter<?>> messageConverters;private ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();/*** 响应体的后置增强器*/private final List<Object> responseBodyAdvice = new ArrayList<>();@Nullableprivate ApplicationContext applicationContext;private final Map<Class<?>, ExceptionHandlerMethodResolver> exceptionHandlerCache = new ConcurrentHashMap<>(64);private final Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> exceptionHandlerAdviceCache = new LinkedHashMap<>();public ExceptionHandlerExceptionResolver() {StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();stringHttpMessageConverter.setWriteAcceptCharset(false);  // see SPR-7316// 初始化 messageConvertersthis.messageConverters = new ArrayList<>();this.messageConverters.add(new ByteArrayHttpMessageConverter());this.messageConverters.add(stringHttpMessageConverter);try {this.messageConverters.add(new SourceHttpMessageConverter<>());} catch (Error err) {// Ignore when no TransformerFactory implementation is available}this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());}
}

有没有一种熟悉的感觉，和《HandlerAdapter 组件（一）之 HandlerAdapter》的 RequestMappingHandlerAdapter 类似，有大量的相同变量，例如参数解析器和返回结果处理器，最终也是调用 ServletInvocableHandlerMethod 的方法。因为你定义也是定义的方法去处理相关的异常

afterPropertiesSet

因为 ExceptionHandlerExceptionResolver 实现了 InitializingBean 接口，在 Sping 初始化该 Bean 的时候，会调用该方法，完成一些初始化工作，方法如下：

@Override
public void afterPropertiesSet() {// Do this first, it may add ResponseBodyAdvice beans// 初始化 exceptionHandlerAdviceCache、responseBodyAdviceinitExceptionHandlerAdviceCache();// 初始化 argumentResolvers 参数if (this.argumentResolvers == null) {List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);}// 初始化 returnValueHandlers 参数if (this.returnValueHandlers == null) {List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);}
}

调用 initExceptionHandlerAdviceCache() 方法，初始化 exceptionHandlerAdviceCache、responseBodyAdvice，详情见下文

初始化 argumentResolvers 属性。其中，#getDefaultArgumentResolvers() 方法，获得默认的 HandlerMethodArgumentResolver 数组，详情见下文

初始化 returnValueHandlers 属性。其中，#getDefaultReturnValueHandlers() 方法，获得默认的 HandlerMethodReturnValueHandler 数组，详情见下文

initExceptionHandlerAdviceCache

initExceptionHandlerAdviceCache() 方法，初始化 exceptionHandlerAdviceCache、responseBodyAdvice，方法如下：

private void initExceptionHandlerAdviceCache() {if (getApplicationContext() == null) {return;}// <1> 扫描 @ControllerAdvice 注解的 Bean 们，并将进行排序List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());AnnotationAwareOrderComparator.sort(adviceBeans);// <2> 遍历 ControllerAdviceBean 数组for (ControllerAdviceBean adviceBean : adviceBeans) {Class<?> beanType = adviceBean.getBeanType();if (beanType == null) {throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);}// <2.1> 扫描该 ControllerAdviceBean 对应的类型ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);// <2.2> 有 @ExceptionHandler 注解，则添加到 exceptionHandlerAdviceCache 中if (resolver.hasExceptionMappings()) {this.exceptionHandlerAdviceCache.put(adviceBean, resolver);}// <2.3> 如果该 beanType 类型是 ResponseBodyAdvice 子类，则添加到 responseBodyAdvice 中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");}}
}

调用 ControllerAdviceBean 的 findAnnotatedBeans(ApplicationContext context) 方法，扫描 @ControllerAdvice 注解的 Bean 们，并将进行排序，这里就会扫描到上面示例中 CustomizeExceptionHandler 自定义异常处理类

遍历 ControllerAdviceBean 数组

创建扫描该 ControllerAdviceBean 对应的类型 ExceptionHandlerMethodResolver 对象 resolver，该对象在下面会分析

有 @ExceptionHandler 注解，则将resolver添加到 exceptionHandlerAdviceCache 中

如果该 beanType 类型是 ResponseBodyAdvice 子类，则添加到 responseBodyAdvice 中

getDefaultArgumentResolvers

getDefaultArgumentResolvers() 方法，获得默认的 HandlerMethodArgumentResolver 数组，方法如下：

protected List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();// Annotation-based argument resolutionresolvers.add(new SessionAttributeMethodArgumentResolver());resolvers.add(new RequestAttributeMethodArgumentResolver());// Type-based argument resolutionresolvers.add(new ServletRequestMethodArgumentResolver());resolvers.add(new ServletResponseMethodArgumentResolver());resolvers.add(new RedirectAttributesMethodArgumentResolver());resolvers.add(new ModelMethodProcessor());// Custom argumentsif (getCustomArgumentResolvers() != null) {resolvers.addAll(getCustomArgumentResolvers());}return resolvers;
}

getDefaultReturnValueHandlers

getDefaultReturnValueHandlers() 方法，获得默认的 HandlerMethodReturnValueHandler 数组，方法如下：

protected List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>();// Single-purpose return value typeshandlers.add(new ModelAndViewMethodReturnValueHandler());handlers.add(new ModelMethodProcessor());handlers.add(new ViewMethodReturnValueHandler());handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));// Annotation-based return value typeshandlers.add(new ModelAttributeMethodProcessor(false));handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));// Multi-purpose return value typeshandlers.add(new ViewNameMethodReturnValueHandler());handlers.add(new MapMethodProcessor());// Custom return value typesif (getCustomReturnValueHandlers() != null) {handlers.addAll(getCustomReturnValueHandlers());}// Catch-allhandlers.add(new ModelAttributeMethodProcessor(true));return handlers;
}

ExceptionHandlerMethodResolver 类

在 ExceptionHandlerExceptionResolver 的 initExceptionHandlerAdviceCache 方法中会用到，两者的名字太容易混淆了

org.springframework.web.method.annotation.ExceptionHandlerMethodResolver，添加 @ControllerAdvice 注解的 Bean，用于解析添加了 @ExceptionHandler 注解的方法

构造方法

public class ExceptionHandlerMethodResolver {/*** A filter for selecting {@code @ExceptionHandler} methods.* * MethodFilter 对象，用于过滤带有 @ExceptionHandler 注解的方法*/public static final MethodFilter EXCEPTION_HANDLER_METHODS = method ->AnnotatedElementUtils.hasAnnotation(method, ExceptionHandler.class);/*** 已经映射的方法** 在 {@link #ExceptionHandlerMethodResolver(Class)} 构造方法中初始化*/pivate final Map<Class<? extends Throwable>, Method> mappedMethods = new HashMap<>(16);/*** 已经匹配的方法** 在 {@link #resolveMethod(Exception)} 方法中初始化*/private final Map<Class<? extends Throwable>, Method> exceptionLookupCache = new ConcurrentReferenceHashMap<>(16);public ExceptionHandlerMethodResolver(Class<?> handlerType) {// <1> 遍历 @ExceptionHandler 注解的方法，这些方法用于处理对应的异常for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {// <2> 遍历处理的异常集合，获取到该方法能处理哪些异常for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {// <3> 添加到 mappedMethods 中addExceptionMapping(exceptionType, method);}}}
}

mappedMethods 和 exceptionLookupCache 差别在于，后者是经过查找，比较优先级之后所产生的

遍历 @ExceptionHandler 注解的方法

调用 detectExceptionMappings(Method method) 方法，获得方法的异常数组，如下：

private List<Class<? extends Throwable>> detectExceptionMappings(Method method) {List<Class<? extends Throwable>> result = new ArrayList<>();// 首先，从方法上的 @ExceptionHandler 注解中，获得要处理的异常类型，添加到 result 中detectAnnotationExceptionMappings(method, result);// 其次，如果获取不到，从方法参数中，获得所处理的异常，添加到 result 中if (result.isEmpty()) {for (Class<?> paramType : method.getParameterTypes()) {if (Throwable.class.isAssignableFrom(paramType)) {result.add((Class<? extends Throwable>) paramType);}}}// 如果获取不到，则抛出 IllegalStateException 异常if (result.isEmpty()) {throw new IllegalStateException("No exception types mapped to " + method);}return result;
}private void detectAnnotationExceptionMappings(Method method, List<Class<? extends Throwable>> result) {ExceptionHandler ann = AnnotatedElementUtils.findMergedAnnotation(method, ExceptionHandler.class);Assert.state(ann != null, "No ExceptionHandler annotation");result.addAll(Arrays.asList(ann.value()));
}

调用 addExceptionMapping(Class<? extends Throwable> exceptionType, Method method) 方法，添加到 mappedMethods 中，如下：

private void addExceptionMapping(Class<? extends Throwable> exceptionType, Method method) {// 添加到 mappedMethods 中Method oldMethod = this.mappedMethods.put(exceptionType, method);// 如果已存在，说明冲突，所以抛出 IllegalStateException 异常if (oldMethod != null && !oldMethod.equals(method)) {throw new IllegalStateException("Ambiguous @ExceptionHandler method mapped for [" +exceptionType + "]: {" + oldMethod + ", " + method + "}");}
}

hasExceptionMappings

hasExceptionMappings() 方法，判断 mappedMethods 非空，方法如下：

public boolean hasExceptionMappings() {return !this.mappedMethods.isEmpty();
}

resolveMethod

resolveMethod(Exception exception) 方法，获取解析异常对应的方法，方法如下：

@Nullable
public Method resolveMethod(Exception exception) {return resolveMethodByThrowable(exception);
}
@Nullable
public Method resolveMethodByThrowable(Throwable exception) {// 首先，获得异常对应的方法Method method = resolveMethodByExceptionType(exception.getClass());// 其次，获取不到，则使用异常 cause 对应的方法if (method == null) {Throwable cause = exception.getCause();if (cause != null) {method = resolveMethodByExceptionType(cause.getClass());}}return method;
}

按照 exception 和 exception.cause 的先后，调用 resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) 方法，获得异常对应的方法，如下：

@Nullable
public Method resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) {// 首先，先从 exceptionLookupCache 缓存中获得异常对应的处理方法Method method = this.exceptionLookupCache.get(exceptionType);// 其次，获取不到，则从 mappedMethods 中获得，并添加到 exceptionLookupCache 中if (method == null) {method = getMappedMethod(exceptionType);this.exceptionLookupCache.put(exceptionType, method);}return method;
}

逻辑比较简单，调用 getMappedMethod(Class<? extends Throwable> exceptionType) 方法，获得异常对应的方法，如下：

@Nullable
private Method getMappedMethod(Class<? extends Throwable> exceptionType) {List<Class<? extends Throwable>> matches = new ArrayList<>();// 遍历 mappedMethods 数组，匹配异常，添加到 matches 中for (Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {if (mappedException.isAssignableFrom(exceptionType)) {matches.add(mappedException);}}// 将匹配的结果，排序，选择第一个if (!matches.isEmpty()) {matches.sort(new ExceptionDepthComparator(exceptionType));return this.mappedMethods.get(matches.get(0));}else {return null;}
}

逻辑比较简单，关于 org.springframework.core.ExceptionDepthComparator 比较器，胖友自己点击传送门查看。大体的逻辑是，比较它们和目标类的继承层级，越小越匹配。

getExceptionHandlerMethod

getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) 方法，获得异常对应的 ServletInvocableHandlerMethod 对象，代码如下：

@Nullable
protected ServletInvocableHandlerMethod getExceptionHandlerMethod(@Nullable HandlerMethod handlerMethod, Exception exception) {// 处理器的类型Class<?> handlerType = null;// <1> 首先，如果 handlerMethod 非空，则先获得 Controller 对应的 @ExceptionHandler 处理器对应的方法if (handlerMethod != null) {// Local exception handler methods on the controller class itself.// To be invoked through the proxy, even in case of an interface-based proxy.// 获得 handlerTypehandlerType = handlerMethod.getBeanType();// 获得 handlerType 对应的 ExceptionHandlerMethodResolver 对象ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);if (resolver == null) {resolver = new ExceptionHandlerMethodResolver(handlerType);this.exceptionHandlerCache.put(handlerType, resolver);}// 获得异常对应的 Method 处理方法Method method = resolver.resolveMethod(exception);// 如果获得该异常对应的 Method 处理方法，则创建 ServletInvocableHandlerMethod 对象，并返回if (method != null) {return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);}// For advice applicability check below (involving base packages, assignable types// and annotation presence), use target class instead of interface-based proxy.// 获得 handlerType 的原始类。因为，此处有可能是代理对象if (Proxy.isProxyClass(handlerType)) {handlerType = AopUtils.getTargetClass(handlerMethod.getBean());}}// <2> 其次，使用 ControllerAdvice 对应的 @ExceptionHandler 处理器对应的方法for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {ControllerAdviceBean advice = entry.getKey();// 如果 ControllerAdvice 支持当前的 handlerTypeif (advice.isApplicableToBeanType(handlerType)) {// 获得 handlerType 对应的 ExceptionHandlerMethodResolver 对象ExceptionHandlerMethodResolver resolver = entry.getValue();// 获得异常对应的 Method 处理方法Method method = resolver.resolveMethod(exception);if (method != null) {return new ServletInvocableHandlerMethod(advice.resolveBean(), method);}}}// 最差，获取不到return null;
}

首先，如果 handlerMethod 非空，则先获得 Controller 对应的 @ExceptionHandler 处理器对应的方法，如果获取到了，则将该 Method 封装成 ServletInvocableHandlerMethod 对象并返回

其次，使用 ControllerAdvice 对应的 @ExceptionHandler 处理器对应的方法，如果获取到了，则将该 Method 封装成 ServletInvocableHandlerMethod 对象并返回

最差，获取不到，返回 null

上面第 2 种情况也就是示例中定义的方法哦~

doResolveHandlerMethodException

实现 doResolveHandlerMethodException(ttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) 方法，处理异常，代码如下：

@Override
@Nullable
protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {// <1> 获得异常对应的 ServletInvocableHandlerMethod 对象ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);if (exceptionHandlerMethod == null) {return null;}// <1.1> 设置 ServletInvocableHandlerMethod 对象的相关属性if (this.argumentResolvers != null) {exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);}if (this.returnValueHandlers != null) {exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);}// <1.2> 创建 ServletWebRequest 对象ServletWebRequest webRequest = new ServletWebRequest(request, response);// <1.3> 创建 ModelAndViewContainer 对象ModelAndViewContainer mavContainer = new ModelAndViewContainer();try {if (logger.isDebugEnabled()) {logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);}// <2> // 执行处理该异常的方法 ServletInvocableHandlerMethod 的调用Throwable cause = exception.getCause();if (cause != null) {// Expose cause as provided argument as wellexceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);}else {// Otherwise, just the given exception as-isexceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);}}catch (Throwable invocationEx) {// Any other than the original exception is unintended here,// probably an accident (e.g. failed assertion or the like).// <2.1> 发生异常，则直接返回if (invocationEx != exception && logger.isWarnEnabled()) {logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);}// Continue with default processing of the original exception...return null;}// <3> 如果 mavContainer 已处理，则返回 '空的' ModelAndView 对象。if (mavContainer.isRequestHandled()) {return new ModelAndView();}// <4> 如果 mavContainer 未处，则基于 `mavContainer` 生成 ModelAndView 对象else {ModelMap model = mavContainer.getModel();HttpStatus status = mavContainer.getStatus();// <4.1> 创建 ModelAndView 对象，并设置相关属性ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);mav.setViewName(mavContainer.getViewName());if (!mavContainer.isViewReference()) {mav.setView((View) mavContainer.getView());}// <4.2>if (model instanceof RedirectAttributes) {Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);}return mav;}
}

调用 getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) 方法，获得异常对应的 ServletInvocableHandlerMethod 对象

设置 ServletInvocableHandlerMethod 对象的相关属性，参数解析器，返回结果处理器

创建 ServletWebRequest 对象 webRequest，封装了请求和响应

创建 ModelAndViewContainer 对象 mavContainer，用于获取 ModelAndView 对象

执行处理该异常的方法，ServletInvocableHandlerMethod 对象的调用

在《HandlerAdapter 组件（二）之 ServletInvocableHandlerMethod》中已经详细的分析过了

此处传入了 Object... providedArgs 参数为 exception 和 handlerMethod 变量，这也是为什么 @ExceptionHanlder 注解的方法，可以设置为这两个参数

发生异常，则直接返回

如果 mavContainer 已处理，则返回 “空的” ModelAndView 对象。这样，就不会被后续的 ViewResolver 所处理。为什么呢？可以自己回看下 DispatcherServlet 的 processHandlerException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 方法，很容易明白

如果 mavContainer 未处理，则基于 mavContainer 生成 ModelAndView 对象

创建 ModelAndView 对象，并设置相关属性，视图名称

FlashMapManager 相关，暂时忽略

ResponseStatusExceptionResolver

org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver，实现 MessageSourceAware 接口，继承 AbstractHandlerExceptionResolver 抽象类，基于 @ResponseStatus 提供错误响应的 HandlerExceptionResolver 实现类

构造方法

public class ResponseStatusExceptionResolver extends AbstractHandlerExceptionResolver implements MessageSourceAware {@Nullableprivate MessageSource messageSource;
}

applyStatusAndReason

applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response) 方法，设置错误响应，方法如下：

protected ModelAndView applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response)throws IOException {// 情况一，如果无错误提示，则响应只设置状态码if (!StringUtils.hasLength(reason)) {response.sendError(statusCode);}// 情况二，如果有错误信息，则响应设置状态码 + 错误提示else {// 进一步解析错误提示，如果有 messageSource 的情况下String resolvedReason = (this.messageSource != null ?this.messageSource.getMessage(reason, null, reason, LocaleContextHolder.getLocale()) :reason);// 设置response.sendError(statusCode, resolvedReason);}// 创建“空” ModelAndView 对象，并返回return new ModelAndView();
}

注意，此处返回的也是“空”的 ModelAndView 对象。这样，就不会被后续的 ViewResolver 所处理

doResolveException

实现 doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 方法，代码如下：

@Override
@Nullable
protected ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {try {// <1> 情况一，如果异常是 ResponseStatusException 类型，进行解析并设置到响应if (ex instanceof ResponseStatusException) {return resolveResponseStatusException((ResponseStatusException) ex, request, response, handler);}// <2> 情况二，如果有 @ResponseStatus 注解，进行解析并设置到响应ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(ex.getClass(), ResponseStatus.class);if (status != null) {return resolveResponseStatus(status, request, response, handler, ex);}// <3> 情况三，使用异常的 cause 在走一次情况一、情况二的逻辑。if (ex.getCause() instanceof Exception) {return doResolveException(request, response, handler, (Exception) ex.getCause());}}catch (Exception resolveEx) {if (logger.isWarnEnabled()) {logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", resolveEx);}}return null;
}

1、情况一，如果异常是 ResponseStatusException 类型，进行解析并设置到响应，调用 resolveResponseStatusException(ResponseStatusException ex, HttpServletRequest request, HttpServletResponse response, Object handler) 方法，如下：

protected ModelAndView resolveResponseStatusException(ResponseStatusException ex,HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) throws Exception {int statusCode = ex.getStatus().value();String reason = ex.getReason();return applyStatusAndReason(statusCode, reason, response);
}

2、情况二，如果有 @ResponseStatus 注解，进行解析并设置到响应，调用 resolveResponseStatus(ResponseStatus responseStatus, HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

方法，如下：

protected ModelAndView resolveResponseStatus(ResponseStatus responseStatus, HttpServletRequest request,HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {int statusCode = responseStatus.code().value();String reason = responseStatus.reason();return applyStatusAndReason(statusCode, reason, response);
}

3、情况三，使用异常的 cause 再走一次情况一、情况二的逻辑

DefaultHandlerExceptionResolver

org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver，继承 AbstractHandlerExceptionResolver 抽象类，默认 HandlerExceptionResolver 实现类，针对各种异常，设置错误响应码

其中，实现 doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 方法，代码如下：

@Override
@Nullable
protected ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {try {if (ex instanceof HttpRequestMethodNotSupportedException) {return handleHttpRequestMethodNotSupported((HttpRequestMethodNotSupportedException) ex, request, response, handler);}else if (ex instanceof HttpMediaTypeNotSupportedException) {return handleHttpMediaTypeNotSupported((HttpMediaTypeNotSupportedException) ex, request, response, handler);}else if (ex instanceof HttpMediaTypeNotAcceptableException) {return handleHttpMediaTypeNotAcceptable((HttpMediaTypeNotAcceptableException) ex, request, response, handler);}else if (ex instanceof MissingPathVariableException) {return handleMissingPathVariable((MissingPathVariableException) ex, request, response, handler);}else if (ex instanceof MissingServletRequestParameterException) {return handleMissingServletRequestParameter((MissingServletRequestParameterException) ex, request, response, handler);}else if (ex instanceof ServletRequestBindingException) {return handleServletRequestBindingException((ServletRequestBindingException) ex, request, response, handler);}else if (ex instanceof ConversionNotSupportedException) {return handleConversionNotSupported((ConversionNotSupportedException) ex, request, response, handler);}else if (ex instanceof TypeMismatchException) {return handleTypeMismatch((TypeMismatchException) ex, request, response, handler);}else if (ex instanceof HttpMessageNotReadableException) {return handleHttpMessageNotReadable((HttpMessageNotReadableException) ex, request, response, handler);}else if (ex instanceof HttpMessageNotWritableException) {return handleHttpMessageNotWritable((HttpMessageNotWritableException) ex, request, response, handler);}else if (ex instanceof MethodArgumentNotValidException) {return handleMethodArgumentNotValidException((MethodArgumentNotValidException) ex, request, response, handler);}else if (ex instanceof MissingServletRequestPartException) {return handleMissingServletRequestPartException((MissingServletRequestPartException) ex, request, response, handler);}else if (ex instanceof BindException) {return handleBindException((BindException) ex, request, response, handler);}else if (ex instanceof NoHandlerFoundException) {return handleNoHandlerFoundException((NoHandlerFoundException) ex, request, response, handler);}else if (ex instanceof AsyncRequestTimeoutException) {return handleAsyncRequestTimeoutException((AsyncRequestTimeoutException) ex, request, response, handler);}}catch (Exception handlerEx) {if (logger.isWarnEnabled()) {logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", handlerEx);}}return null;
}

逻辑不复杂，根据不同的异常，设置响应码和错误信息，例如 HTTP 方法类型不支持，如下：

protected ModelAndView handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException ex,HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) throws IOException {String[] supportedMethods = ex.getSupportedMethods();if (supportedMethods != null) {response.setHeader("Allow", StringUtils.arrayToDelimitedString(supportedMethods, ", "));}// 405 状态码，HTTP Method 不支持response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, ex.getMessage());return new ModelAndView();
}

注意，返回的都是“空”的 ModelAndView 对象。这样，就不会被后续的 ViewResolver 所处理

总结

本文对 Spring MVC 中的 HandlerExceptionResolver 组件进行分析，处理器异常解析器，将处理器（ handler ）执行时发生的异常（也就是处理请求，执行方法的过程中发生的异常）解析（转换）成对应的 ModelAndView 结果

HandlerExceptionResolver 的实现类没有特别多，不过也采用了组合模式，如果某个异常处理器进行处理了，也就是返回的 ModeAndView 不为 null（一般都是“空”对象），则直接返回该 ModeAndView 对象

在 Spring MVC 和 Spring Boot 中，默认情况下都有三种 HandlerExceptionResolver 实现类，他们的顺序如下：

ExceptionHandlerExceptionResolver：基于 @ExceptionHandler 配置 HandlerMethod 的 HandlerExceptionResolver 实现类。例如通过 @ControllerAdvice 注解自定义异常处理器，加上@ExceptionHandler注解指定方法所需要处理的异常类型，这种方式就在这个实现类中实现的。没有使用过这两个注解可以参考上面的示例

ResponseStatusExceptionResolver：基于 @ResponseStatus 提供错误响应的 HandlerExceptionResolver 实现类。例如在方法上面添加 @ResponseStatus 注解，指定该方法发生异常时，需要设置的 code 响应码和 reason 错误信息