# 精尽 Spring MVC 源码解析 —— HandlerExceptionResolver 组件

# 1. 概述

本文，我们来分享 HandlerExceptionResolver 组件。在 [《精尽 Spring MVC 源码分析 —— 组件一览》](http://svip.iocoder.cn/Spring-MVC/Components-intro) 中，我们对它已经做了介绍：

`org.springframework.web.servlet.HandlerExceptionResolver` ，处理器异常解析器接口，将处理器( `handler` )执行时发生的异常，解析( 转换 )成对应的 ModelAndView 结果。代码如下：

```
// HandlerExceptionResolver.java

public interface HandlerExceptionResolver {

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

}
```

- 也就是说，如果异常被**解析成功**，则会返回 ModelAndView 对象。

# 2. 类图

HandlerExceptionResolver 的类图如下：

[![类图](19-Spring MVC 源码解析-HandlerExceptionResolver 组件.assets/01.png)](http://static.iocoder.cn/images/Spring/2022-06-01/01.png)类图

# 3. 初始化

仔细一瞅，类还是不少的哈。我们以**默认配置的 Spring Boot 场景**下为例，来一起看看 DispatcherServlet 的 `#initHandlerExceptionResolvers(ApplicationContext context)` 方法，初始化 `handlerExceptionResolvers` 变量。代码如下：

```
// DispatcherServlet.java

/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean?. */
private boolean detectAllHandlerExceptionResolvers = true;
    
@Nullable
private List<HandlerExceptionResolver> handlerExceptionResolvers;

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 的 Bean 们
    } else {
        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 类
    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");
        }
    }
}
```

- 一共有三种情况，初始化 `handlerExceptionResolvers` 属性。

- 默认情况下，

  ```
  detectAllHandlerExceptionResolvers
  ```

   

  为

   

  ```
  true
  ```

   

  ，所以走

  情况一

  的逻辑，自动扫描 HandlerExceptionResolver 类型的 Bean 们。在

  默认配置的 Spring Boot 场景

  下，

  ```
  handlerExceptionResolvers
  ```

   

  的结果是：

  - `org.springframework.boot.autoconfigure.web.DefaultErrorAttributes`
  - HandlerExceptionResolverComposite

所以，我们可以先忽略掉 SpringBoot 中实现的 DefaultErrorAttributes 类，而来到 [「4. HandlerExceptionResolverComposite」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 中。

> 艿艿：DefaultErrorAttributes 的代码逻辑非常简单，并且是相对“酱油”的逻辑，胖友自己去瞅瞅即可。

# 4. HandlerExceptionResolverComposite

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

## 4.1 构造方法

```
// HandlerExceptionResolverComposite.java

/**
 * resolvers 数组
 */
@Nullable
private List<HandlerExceptionResolver> resolvers;

/**
 * 优先级，最低
 */
private int order = Ordered.LOWEST_PRECEDENCE;
```

那么，还是让我们来看看，在**默认配置的 Spring Boot 场景**下，是通过 WebMvcConfigurationSupport 的 `#handlerExceptionResolver()` 方法，进行初始化。代码如下：

```
// WebMvcConfigurationSupport.java

@Bean
public HandlerExceptionResolver handlerExceptionResolver() {
    // <1> 创建 HandlerExceptionResolver 数组
    List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
    // <1.1> 添加配置的 HandlerExceptionResolver 到 exceptionResolvers 中
    configureHandlerExceptionResolvers(exceptionResolvers);
    // <1.2> 如果 exceptionResolvers 为空，添加默认 HandlerExceptionResolver 数组
    if (exceptionResolvers.isEmpty()) {
        addDefaultHandlerExceptionResolvers(exceptionResolvers);
    }
    // <1.3> 子类定义的 HandlerExceptionResolver 数组，到 exceptionResolvers 中
    extendHandlerExceptionResolvers(exceptionResolvers);

    // <2> 创建 HandlerExceptionResolverComposite 数组
    HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
    composite.setOrder(0);
    composite.setExceptionResolvers(exceptionResolvers);
    return composite;
}
```

- `@Bean` 注解，注册一个类型为 HandlerExceptionResolver 的 Bean 对象。所以，在 [「3. 初始化」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 可以被扫描到。

- `<1>` 处，创建 HandlerExceptionResolver 数组 `exceptionResolvers` 。

  - `<1.1>` 处，添加配置的 HandlerExceptionResolver 到 `exceptionResolvers` 中。默认情况下，不会配置。所以感兴趣的胖友，自己去看。

  - `<1.2>` 处，因为此时 `exceptionResolvers` 为空，所以调用 `#addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers)` 方法，添加**默认** HandlerExceptionResolver 数组。代码如下：

    ```
    // WebMvcConfigurationSupport.java
    
    protected final void addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
    	// 创建 ExceptionHandlerExceptionResolver 对象
    	ExceptionHandlerExceptionResolver exceptionHandlerResolver = createExceptionHandlerExceptionResolver();
    	exceptionHandlerResolver.setContentNegotiationManager(mvcContentNegotiationManager());
    	exceptionHandlerResolver.setMessageConverters(getMessageConverters());
    	exceptionHandlerResolver.setCustomArgumentResolvers(getArgumentResolvers());
    	exceptionHandlerResolver.setCustomReturnValueHandlers(getReturnValueHandlers());
    	if (jackson2Present) {
    		exceptionHandlerResolver.setResponseBodyAdvice(
    				Collections.singletonList(new JsonViewResponseBodyAdvice()));
    	}
    	if (this.applicationContext != null) {
    		exceptionHandlerResolver.setApplicationContext(this.applicationContext);
    	}
    	exceptionHandlerResolver.afterPropertiesSet();
    	exceptionResolvers.add(exceptionHandlerResolver);
    
    	// 创建 ResponseStatusExceptionResolver 对象
    	ResponseStatusExceptionResolver responseStatusResolver = new ResponseStatusExceptionResolver();
    	responseStatusResolver.setMessageSource(this.applicationContext);
    	exceptionResolvers.add(responseStatusResolver);
    
    	// 创建 DefaultHandlerExceptionResolver 对象
    	exceptionResolvers.add(new DefaultHandlerExceptionResolver());
    }
    ```

    - 依次创建 ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver 对象，添加到 `exceptionResolvers` 中。

  - `<1.3>` 处，子类定义的 HandlerExceptionResolver 数组，到 `exceptionResolvers` 中。默认情况下，无定义。所以，可以无视先。

- `<2>` 处，创建 HandlerExceptionResolverComposite 数组。

## 4.2 resolveException

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

```
// WebMvcConfigurationSupport.java

@Override
@Nullable
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
        @Nullable Object handler,Exception ex) {
    if (this.resolvers != null) {
        // 遍历 HandlerExceptionResolver 数组，逐个处理异常 ex ，如果成功，则返回 ModelAndView 对象
        for (HandlerExceptionResolver handlerExceptionResolver : this.resolvers) {
            ModelAndView mav = handlerExceptionResolver.resolveException(request, response, handler, ex);
            if (mav != null) {
                return mav;
            }
        }
    }
    return null;
}
```

# 5. AbstractHandlerExceptionResolver

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

## 5.1 构造方法

```
// AbstractHandlerExceptionResolver.java

/**
 * 顺序，优先级最低
 */
private int order = Ordered.LOWEST_PRECEDENCE;

/**
 * 匹配的处理器对象的集合
 */
@Nullable
private Set<?> mappedHandlers;

/**
 * 匹配的处理器类型的数组
 */
@Nullable
private Class<?>[] mappedHandlerClasses;

@Nullable
private Log warnLogger;

/**
 * 防止响应缓存
 */
private boolean preventResponseCaching = false;
```

- 每个属性，我们放在下面的方法，进行详细解析。

## 5.2 shouldApplyTo

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

```
// AbstractHandlerExceptionResolver.java

protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {
    if (handler != null) {
        // <1> 如果 mappedHandlers 包含 handler 对象，则返回 true
        if (this.mappedHandlers != null && this.mappedHandlers.contains(handler)) {
            return true;
        }
        // <2> 如果 mappedHandlerClasses 包含 handler 的类型，则返回 true
        if (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);
}
```

- 有 `<1>`、`<2>`、`<3>` 种情况，可以满足条件。

## 5.3 prepareResponse

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

```
// AbstractHandlerExceptionResolver.java

private static final String HEADER_CACHE_CONTROL = "Cache-Control";

protected void prepareResponse(Exception ex, HttpServletResponse response) {
	if (this.preventResponseCaching) {
		preventCaching(response);
	}
}

protected void preventCaching(HttpServletResponse response) {
	response.addHeader(HEADER_CACHE_CONTROL, "no-store");
}
```

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

## 5.4 resolveException

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

```
// AbstractHandlerExceptionResolver.java

@Override
@Nullable
public ModelAndView resolveException(
        HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
    // 判断是否可以应用
    if (shouldApplyTo(request, handler)) {
        // 阻止缓存
        prepareResponse(ex, response);
        // 执行解析异常，返回 ModelAndView 对象
        ModelAndView result = doResolveException(request, response, handler, ex);
        // 如果 ModelAndView 对象非空，则进行返回
        if (result != null) {
            // Print warn message when warn logger is not enabled...
            if (logger.isWarnEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {
                logger.warn("Resolved [" + ex + "]" + (result.isEmpty() ? "" : " to " + result));
            }
            // 打印异常日志
            // warnLogger with full stack trace (requires explicit config)
            logException(ex, request);
        }
        // 返回 ModelAndView 对象
        return result;
    // 不可应用，直接返回 null
    } else {
        return null;
    }
}
```

- 逻辑非常简单，胖友自己看着注释来瞅瞅即懂。

- `<1>` 处，调用 `#doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)` **抽象**方法，执行解析异常，返回 ModelAndView 对象。代码如下：

  ```
  // AbstractHandlerExceptionResolver.java
  
  @Nullable
  protected abstract ModelAndView doResolveException(
  		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
  ```

  - 子类通过实现该抽象方法，实现自己的处理异常逻辑。

- `<2>` 处，调用 `#logException(Exception ex, HttpServletRequest request)` 方法，打印异常日志。代码如下：

  ```
  // AbstractHandlerExceptionResolver.java
  
  protected void logException(Exception ex, HttpServletRequest request) {
  	if (this.warnLogger != null && this.warnLogger.isWarnEnabled()) {
  		this.warnLogger.warn(buildLogMessage(ex, request));
  	}
  }
  ```

# 6. AbstractHandlerMethodExceptionResolver

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

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

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

## 6.1 shouldApplyTo

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

```
// AbstractHandlerMethodExceptionResolver.java

@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> 获得真正的 handler
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        handler = handlerMethod.getBean();
        // 调用父方法
        return super.shouldApplyTo(request, handler);
    // 情况三，直接返回 false
    } else {
        return false;
    }
}
```

- 重点在于情况二，需要在 `<x>` 处，调用 `HandlerMethod#getBean()` 方法，获得真正的 `handler` 处理器。为什么呢？胖友自己翻翻前面的文章，找找原因。😈

## 6.2 doResolveException

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

```
// AbstractHandlerMethodExceptionResolver.java

@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 类型，并提供新的抽象方法。

# 7. ExceptionHandlerExceptionResolver

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

可能有的胖友并没有使用 `@ExceptionHandler` 注解来实现过异常的处理，可以先看看 [《Spring 异常处理 ExceptionHandler 的使用》](https://www.jianshu.com/p/12e1a752974d) 。

- 一般情况下，艿艿喜欢使用**第三种**。

## 7.1 构造方法

```
// ExceptionHandlerExceptionResolver.java

@Nullable
private List<HandlerMethodArgumentResolver> customArgumentResolvers;

@Nullable
private HandlerMethodArgumentResolverComposite argumentResolvers;

@Nullable
private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;

@Nullable
private HandlerMethodReturnValueHandlerComposite returnValueHandlers;

private List<HttpMessageConverter<?>> messageConverters;

private ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();

private final List<Object> responseBodyAdvice = new ArrayList<>();

@Nullable
private 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

	// 初始化 messageConverters
	this.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());
}
```

- 和 [《精尽 Spring MVC 源码解析 —— HandlerAdapter 组件（一）之 HandlerAdapter》](http://svip.iocoder.cn/Spring-MVC/HandlerAdapter-1-HandlerAdapter) 的 [「7. RequestMappingHandlerAdapter」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 类似，有大量的相同变量，也是最终调用 ServletInvocableHandlerMethod 的方法。😈 可能胖友有点闷逼？继续往下瞅，哈哈哈哈。

## 7.2 afterPropertiesSet

`#afterPropertiesSet()` 方法，进一步初始化 ExceptionHandlerExceptionResolver 。代码如下：

```
// ExceptionHandlerExceptionResolver.java

@Override
public void afterPropertiesSet() {
    // Do this first, it may add ResponseBodyAdvice beans
    // 初始化 exceptionHandlerAdviceCache、responseBodyAdvice
    initExceptionHandlerAdviceCache();

    // 初始化 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);
    }
}
```

- `<1>` 处，调用 `#initExceptionHandlerAdviceCache()` 方法，初始化 `exceptionHandlerAdviceCache`、`responseBodyAdvice` 。详细解析，见 [「7.2.1 initExceptionHandlerAdviceCache」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 。
- `<2>` 处，初始化 `argumentResolvers` 属性。其中，`#getDefaultArgumentResolvers()` 方法，获得默认的 HandlerMethodArgumentResolver 数组。详细解析，见 [「7.2.2 getDefaultArgumentResolvers」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 。
- `<3>` 处，初始化 `returnValueHandlers` 属性。其中，`#getDefaultReturnValueHandlers()` 方法，获得默认的 HandlerMethodReturnValueHandler 数组。详细解析，见 [「7.2.3 getDefaultReturnValueHandlers」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 。

### 7.2.1 initExceptionHandlerAdviceCache

`#initExceptionHandlerAdviceCache()` 方法，初始化 `exceptionHandlerAdviceCache`、`responseBodyAdvice` 。代码如下：

```
// ExceptionHandlerExceptionResolver.java

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

- `<1>` 处，调用 `ControllerAdviceBean#findAnnotatedBeans(ApplicationContext context)` 方法，扫描 `@ControllerAdvice` 注解的 Bean 们，并将进行排序。可能有胖友不熟悉这个注解，可以看看 [《Spring 3.2 新注解 @ControllerAdvice》](http://jinnianshilongnian.iteye.com/blog/1866350) 。

- ```
  <2>
  ```

   

  处，遍历 ControllerAdviceBean 数组。

  - `<2.1>` + `<2.2>` 处，扫描该 ControllerAdviceBean 对应的类型，如果有 `@ExceptionHandler` 注解，则添加到 `exceptionHandlerAdviceCache` 中。关于 ExceptionHandlerMethodResolver 类，胖友可以先跳到 [「7.3 ExceptionHandlerMethodResolver」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 小节，看完后回来。
  - `<2.3>` 处，如果该 `beanType` 类型是 ResponseBodyAdvice 子类，则添加到 `responseBodyAdvice` 中。

### 7.2.2 getDefaultArgumentResolvers

`#getDefaultArgumentResolvers()` 方法，获得默认的 HandlerMethodArgumentResolver 数组。见 [传送门](https://github.com/spring-projects/spring-framework/blob/master/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java#L318-L341) 。

### 7.2.3 getDefaultReturnValueHandlers

`#getDefaultReturnValueHandlers()` 方法，获得默认的 HandlerMethodReturnValueHandler 数组。见 [传送门](https://github.com/spring-projects/spring-framework/blob/master/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java#L343-L375) 。

## 7.3 ExceptionHandlerMethodResolver

> 艿艿：关于 ExceptionHandlerMethodResolver 类，因为只有 ExceptionHandlerExceptionResolver 类在用，所以放在此处。😈 不过 ExceptionHandlerExceptionResolver 的类名，看起来好容易混淆。。。

`org.springframework.web.method.annotation.ExceptionHandlerMethodResolver`，注解了 `@ExceptionHandler` 的方法的解析器。

### 7.3.1 构造方法

```
// ExceptionHandlerMethodResolver.java

/**
 * 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)} 构造方法中初始化
 */
private 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` 差别在于，后者是经过查找，比较优先级后所产生的。

- `<1>` 处，遍历 `@ExceptionHandler` 注解的方法。

- `<2>` 处，调用 `#detectExceptionMappings(Method method)` 方法，获得方法的异常数组。代码如下：

  ```
  // ExceptionHandlerMethodResolver.java
  
  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()));
  }
  ```

- `<3>` 处，调用 `#addExceptionMapping(Class<? extends Throwable> exceptionType, Method method)` 方法，添加到 `mappedMethods` 中。代码如下：

  ```
  // ExceptionHandlerMethodResolver.java
  
  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 + "}");
      }
  }
  ```

### 7.3.2 hasExceptionMappings

`#hasExceptionMappings()` 方法，判断 `mappedMethods` 非空。代码如下：

```
// ExceptionHandlerMethodResolver.java

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

### 7.3.3 resolveMethod

`#resolveMethod(Exception exception)` 方法，解析异常对应的方法。代码如下：

```
// ExceptionHandlerMethodResolver.java

@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)` 方法，获得异常对应的方法。代码如下：

  ```
  // ExceptionHandlerMethodResolver.java
  
  @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)` 方法，获得异常对应的方法。代码如下：

    ```
    // ExceptionHandlerMethodResolver.java
    
    @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` 比较器，胖友自己点击 [传送门](https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/core/ExceptionDepthComparator.java) 查看。大体的逻辑是，比较它们和目标类的**继承层级**，越小越匹配。

## 7.4 getExceptionHandlerMethod

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

```
// ExceptionHandlerMethodResolver.java

@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.
        // 获得 handlerType
        handlerType = 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 支持当前的 handlerType
        if (advice.isApplicableToBeanType(handlerType)) {
            // 获得 handlerType 对应的 ExceptionHandlerMethodResolver 对象
            ExceptionHandlerMethodResolver resolver = entry.getValue();
            // 获得异常对应的 Method 方法
            Method method = resolver.resolveMethod(exception);
            // 如果获得到 Method 方法，则创建 ServletInvocableHandlerMethod 对象，并返回
            if (method != null) {
                return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
            }
        }
    }

    // 最差，获取不到
    return null;
}
```

- 虽然代码比较多，但是总体分成 `<1>`、`<2>` 两大种情况。
- ========== 第一种 `@Controller` 级 ==========
- `<1>` 处，首先，如果 `handlerMethod` 非空，则先获得 Controller 对应的 `@ExceptionHandler` 处理器对应的方法。
- 剩余的部分，胖友看代码注释
- ========== 第二种 `@ControllerAdvice` 级 ==========
- `<2>` 处，其次，使用 ControllerAdvice 对应的 `@ExceptionHandler` 处理器对应的方法。
- 剩余的部分，胖友看代码注释
- ========= 分割线 =========
- 当然，也有可能获取不到的情况，则会返回 `null` 。

## 7.5 doResolveHandlerMethodException

实现 `#doResolveHandlerMethodException(ttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod, Exception exception)` 方法，代码如下：

```
// ExceptionHandlerMethodResolver.java

@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 well
            exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);
        } else {
            // Otherwise, just the given exception as-is
            exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);
        }
    } catch (Throwable invocationEx) {
        // <2.1> 发生异常，则直接返回
        // Any other than the original exception is unintended here,
        // probably an accident (e.g. failed assertion or the like).
        if (invocationEx != exception && logger.isWarnEnabled()) {
            logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
        }
        // Continue with default processing of the original exception...
        return null;
    }

    // <3.1> 如果 mavContainer 已处理，则返回“空”的 ModelAndView 对象。
    if (mavContainer.isRequestHandled()) {
        return new ModelAndView();
    // <3.2> 如果 mavContainer 未处，则基于 `mavContainer` 生成 ModelAndView 对象
    } else {
        ModelMap model = mavContainer.getModel();
        HttpStatus status = mavContainer.getStatus();
        // <3.2.1> 创建 ModelAndView 对象，并设置相关属性
        ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
        mav.setViewName(mavContainer.getViewName());
        if (!mavContainer.isViewReference()) {
            mav.setView((View) mavContainer.getView());
        }
        // <3.2.2> TODO 1004 flashMapManager
        if (model instanceof RedirectAttributes) {
            Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
            RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
        }
        return mav;
    }
}
```

- ```
  <1>
  ```

   

  处，调用

   

  ```
  #getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception)
  ```

   

  方法，获得异常对应的 ServletInvocableHandlerMethod 对象。详细解析，见

   

  「7.4 getExceptionHandlerMethod」

   

  。

  - `<1.1>` 处，设置 ServletInvocableHandlerMethod 对象的相关属性。

- `<1.2>` 处，创建 ServletWebRequest 对象。

- `<1.3>` 处，创建 ModelAndViewContainer 对象。

- 【重要】

  ```
  <2>
  ```

   

  处，执行 ServletInvocableHandlerMethod 的调用。

  - 在 [《精尽 Spring MVC 源码解析 —— HandlerAdapter 组件（二）之 ServletInvocableHandlerMethod》](http://svip.iocoder.cn/Spring-MVC/HandlerAdapter-2-ServletInvocableHandlerMethod) 中，已经详细解析。如果不太记得的胖友，回去复习下。
  - 【也很重要】比较特别的是，此处传入了 `Object... providedArgs` 参数为 `exception` 和 `handlerMethod` 变量，这也是为什么 `@ExceptionHanlder` 注解的方法，可以设置为这两个参数。😈
  - `<2.1>` 处，发生异常，则直接返回。

- `<3.1>` 处，如果 `mavContainer` **已处理**，则返回“空”的 ModelAndView 对象。😈 这样，就不会被后续的 ViewResolver 所处理。为什么呢？胖友自己回看下 DispatcherServlet 的 `#processHandlerException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)` 方法，就很容易明白。没有明白的话，仔细思考下，或者来星球讨论一波。

- ```
  <3.2>
  ```

   

  处，如果

   

  ```
  mavContainer
  ```

   

  未处，则基于

   

  ```
  mavContainer
  ```

   

  生成 ModelAndView 对象。

  - `<3.2.1>` 处，创建 ModelAndView 对象，并设置相关属性。
  - `<3.2.2>` 处， TODO 1004 flashMapManager

# 8. ResponseStatusExceptionResolver

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

## 8.1 构造方法

```
// ResponseStatusExceptionResolver.java

@Nullable
private MessageSource messageSource;
```

## 8.2 applyStatusAndReason

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

```
// ResponseStatusExceptionResolver.java

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 对象。

## 8.3 doResolveException

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

```
// ResponseStatusExceptionResolver.java

@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) {
            ex = (Exception) ex.getCause();
            return doResolveException(request, response, handler, ex);
        }
    } catch (Exception resolveEx) {
        logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", resolveEx);
    }
    return null;
}
```

- 分成三种情况。

- `<1>` 处，情况一，如果异常是 ResponseStatusException 类型，调用 `#resolveResponseStatus(ResponseStatusException ex, HttpServletRequest request, HttpServletResponse response, Object handler)` 方法，进行解析并设置到响应。代码如下：

  ```
  // ResponseStatusExceptionResolver.java
  
  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)` 方法，进行解析并设置到响应。代码如下：

  ```
  // ResponseStatusExceptionResolver.java
  
  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` 在走一次情况一、情况二的逻辑。

# 9. DefaultHandlerExceptionResolver

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

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

```
// DefaultHandlerExceptionResolver.java

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

比较简单，就不啰嗦解析。感兴趣的胖友，自己去瞅瞅这个类即可。

# 10. SimpleMappingExceptionResolver

> 艿艿：这个类是选读的，不敢兴趣的胖友，可以绕过。

`org.springframework.web.servlet.handler.SimpleMappingExceptionResolver` ，继承 AbstractHandlerExceptionResolver 抽象类，是 Spring MVC 提供的一个简易匹配的异常处理方式。

可通过 XML 中进行配置，示例如下：

```
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
	<!-- 默认异常视图 -->
	<property name="defaultErrorView" value="error" />
	<!-- 视图中获取exception信息变量名 -->
	<property name="exceptionAttribute" value="ex" />
	<!-- 异常同视图映射关系 -->
	<property name="exceptionMappings">
		<props>
			<prop key="com.lcifn.springmvc.exception.BusinessException">businessEx</prop>
		</props>
	</property>
</bean>
```

## 10.1 构造方法

```
// SimpleMappingExceptionResolver.java

/** The default name of the exception attribute: "exception". */
public static final String DEFAULT_EXCEPTION_ATTRIBUTE = "exception";

/**
 * 异常的视图映射
 *
 * KEY：异常的全类名
 * VALUE：视图名
 */
@Nullable
private Properties exceptionMappings;

/**
 * 排除的异常的数组
 */
@Nullable
private Class<?>[] excludedExceptions;

/**
 * 默认视图名
 */
@Nullable
private String defaultErrorView;

/**
 * 默认的状态码
 */
@Nullable
private Integer defaultStatusCode;

/**
 * 状态码的映射
 *
 * KEY：视图名
 * VALUE：状态码
 */
private Map<String, Integer> statusCodes = new HashMap<>();

/**
 * 异常设置到 {@link ModelAndView} 的属性名
 */
@Nullable
private String exceptionAttribute = DEFAULT_EXCEPTION_ATTRIBUTE;
```

- 属性比较多，随着下面的方法，一起瞅瞅。

## 10.2 doResolveException

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

```
// SimpleMappingExceptionResolver.java

@Override
@Nullable
protected ModelAndView doResolveException(
        HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
    // Expose ModelAndView for chosen error view.
    // <1> 获得异常对应的视图
    String viewName = determineViewName(ex, request);
    if (viewName != null) {
        // Apply HTTP status code for error views, if specified.
        // Only apply it if we're processing a top-level request.
        // <2> 获得视图对应的状态码
        Integer statusCode = determineStatusCode(request, viewName);
        // <3> 设置状态码到响应
        if (statusCode != null) {
            applyStatusCodeIfPossible(request, response, statusCode);
        }
        // <4> 创建 ModelAndView 对象，并返回
        return getModelAndView(viewName, ex, request);
    } else {
        return null;
    }
}
```

- `<1>` 处，调用 `#determineViewName(Exception ex, HttpServletRequest request)` 方法，获得异常对应的视图。代码如下：

  ```
  // SimpleMappingExceptionResolver.java
  
  @Nullable
  protected String determineViewName(Exception ex, HttpServletRequest request) {
      String viewName = null;
      // 如果是排除的异常，返回 null
      if (this.excludedExceptions != null) {
          for (Class<?> excludedEx : this.excludedExceptions) {
              if (excludedEx.equals(ex.getClass())) {
                  return null;
              }
          }
      }
      // Check for specific exception mappings.
      // 获得异常对应的视图
      if (this.exceptionMappings != null) {
          viewName = findMatchingViewName(this.exceptionMappings, ex);
      }
      // Return default error view else, if defined.
      // 如果获得不到视图，并且有默认视图，则使用默认视图
      if (viewName == null && this.defaultErrorView != null) {
          if (logger.isDebugEnabled()) {
              logger.debug("Resolving to default view '" + this.defaultErrorView + "'");
          }
          viewName = this.defaultErrorView;
      }
      return viewName;
  }
  ```

  - 其中，调用 `#findMatchingViewName(Properties exceptionMappings, Exception ex)` 方法，获得异常对应的视图。代码如下：

    ```
    // SimpleMappingExceptionResolver.java
    
    @Nullable
    protected String findMatchingViewName(Properties exceptionMappings, Exception ex) {
        String viewName = null;
        String dominantMapping = null;
        int deepest = Integer.MAX_VALUE;
        // 遍历 exceptionMappings 数组，寻找最匹配的视图名
        for (Enumeration<?> names = exceptionMappings.propertyNames(); names.hasMoreElements();) {
            String exceptionMapping = (String) names.nextElement();
            // 获得层级
            int depth = getDepth(exceptionMapping, ex);
            // 如果层级更低，则使用它
            if (depth >= 0 && (depth < deepest || (depth == deepest &&
                    dominantMapping != null && exceptionMapping.length() > dominantMapping.length()))) { // 层级相同，类全名更长，则选择它
                deepest = depth;
                dominantMapping = exceptionMapping;
                viewName = exceptionMappings.getProperty(exceptionMapping);
            }
        }
        // 返回 viewName
        if (viewName != null && logger.isDebugEnabled()) {
            logger.debug("Resolving to view '" + viewName + "' based on mapping [" + dominantMapping + "]");
        }
        return viewName;
    }
    
    protected int getDepth(String exceptionMapping, Exception ex) {
        return getDepth(exceptionMapping, ex.getClass(), 0);
    }
    
    private int getDepth(String exceptionMapping, Class<?> exceptionClass, int depth) {
        // 匹配上
        if (exceptionClass.getName().contains(exceptionMapping)) {
            // Found it!
            return depth;
        }
        // If we've gone as far as we can go and haven't found it...
        // 未匹配上
        if (exceptionClass == Throwable.class) {
            return -1;
        }
        // 递归父类，继续匹配
        return getDepth(exceptionMapping, exceptionClass.getSuperclass(), depth + 1);
    }
    ```

    - 简单，胖友自己瞅瞅即可。

- `<2>` 处，调用 `#determineStatusCode(HttpServletRequest request, String viewName)` 方法，获得视图对应的状态码。代码如下：

  ```
  // SimpleMappingExceptionResolver.java
  
  @Nullable
  protected Integer determineStatusCode(HttpServletRequest request, String viewName) {
  	// 从 statusCodes 中，获得视图名对应的状态码
  	if (this.statusCodes.containsKey(viewName)) {
  		return this.statusCodes.get(viewName);
  	}
  	// 获得不到，使用默认状态码
  	return this.defaultStatusCode;
  }
  ```

- `<3>` 处，调用 `#applyStatusCodeIfPossible(HttpServletRequest request, HttpServletResponse response, int statusCode)` 方法，设置状态码到响应。代码如下：

  ```
  // SimpleMappingExceptionResolver.java
  
  protected void applyStatusCodeIfPossible(HttpServletRequest request, HttpServletResponse response, int statusCode) {
  	if (!WebUtils.isIncludeRequest(request)) {
  		if (logger.isDebugEnabled()) {
  			logger.debug("Applying HTTP status " + statusCode);
  		}
  		response.setStatus(statusCode);
  		request.setAttribute(WebUtils.ERROR_STATUS_CODE_ATTRIBUTE, statusCode);
  	}
  }
  ```

- `<4>` 处，调用 `#getModelAndView(String viewName, Exception ex)` 方法，创建 ModelAndView 对象。代码如下：

  ```
  // SimpleMappingExceptionResolver.java
  
  protected ModelAndView getModelAndView(String viewName, Exception ex) {
  	ModelAndView mv = new ModelAndView(viewName);
  	// 添加 exceptionAttribute
  	if (this.exceptionAttribute != null) {
  		mv.addObject(this.exceptionAttribute, ex);
  	}
  	return mv;
  }
  ```

# 666. 彩蛋

虽然很长，但是实际上，灰常简单。嘿嘿。

参考和推荐如下文章：

- 韩路彪 [《看透 Spring MVC：源代码分析与实践》](https://item.jd.com/11807414.html) 的 [「第16章 HandlerExceptionResolver」](https://svip.iocoder.cn/Spring-MVC/HandlerExceptionResolver/#) 小节