37、Spring源码分析 - 37-Spring MVC的异常处理

在Spring MVC中处理HTTP请求时如果抛出异常会使用DispatcherServlet#processHandlerException()处理，这个方法内部使用Spring MVC默认的注册的HandlerExceptionResolver进行处理。

@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);
   // Check registered HandlerExceptionResolvers...
   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) {
      if (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);
         }
      }
      if (logger.isTraceEnabled()) {
         logger.trace("Using resolved error view: " + exMv, ex);
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Using resolved error view: " + exMv);
      }
      WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
      return exMv;
   }
   throw ex;
}

Spring MVC默认注册了三个HandlerExceptionResolver：

1、 ExceptionHandlerExceptionResolver；
2、 ResponseStatusExceptionResolver；
3、 DefaultHandlerExceptionResolver；

public interface HandlerExceptionResolver {
   //尝试解决在处理程序执行期间抛出的给定异常，返回表示特定错误页面的ModelAndView（如果适用）。
   //返回的ModelAndView可能是empty(ModelAndView.isEmpty())，表示异常已成功解析，但不应呈现任何视图，例如通过设置状态代码。
   @Nullable
   ModelAndView resolveException(
         HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
}

1、AbstractHandlerExceptionResolver

HandlerExceptionResolver实现的抽象基类。支持设置映射处理程序setMappedHandlers()和setMappedHandlerClasses()，解析器应该应用于并实现Ordered接口。

public abstract class AbstractHandlerExceptionResolver implements HandlerExceptionResolver, Ordered {
   private static final String HEADER_CACHE_CONTROL = "Cache-Control";
   /** Logger available to subclasses. */
   protected final Log logger = LogFactory.getLog(getClass());
   private int order = Ordered.LOWEST_PRECEDENCE;
   @Nullable
   private Set<?> mappedHandlers;
   @Nullable
   private Class<?>[] mappedHandlerClasses;
   @Nullable
   private Log warnLogger;
   private boolean preventResponseCaching = false;
   public void setOrder(int order) {
      this.order = order;
   }
   @Override
   public int getOrder() {
      return this.order;
   }

   //指定此异常解析程序应应用于的处理程序集合。异常映射和默认错误视图仅适用于指定的处理程序。
   //如果未设置处理程序或处理程序类，则异常映射和默认错误视图将应用于所有处理程序。 
   //这意味着指定的默认错误视图将用作所有异常的回退; 在这种情况下，链中的任何其他HandlerExceptionResolvers都将被忽略。
   public void setMappedHandlers(Set<?> mappedHandlers) {
      this.mappedHandlers = mappedHandlers;
   }

   //指定此异常解析程序应应用于的类集合。
   //异常映射和缺省错误视图仅适用于指定类型的处理程序; 指定的类型也可以是处理程序的接口或超类。
   //如果未设置处理程序或处理程序类，则异常映射和默认错误视图将应用于所有处理程序。 
   //这意味着指定的默认错误视图将用作所有异常的回退; 在这种情况下，链中的任何其他HandlerExceptionResolvers都将被忽略。
   public void setMappedHandlerClasses(Class<?>... mappedHandlerClasses) {
      this.mappedHandlerClasses = mappedHandlerClasses;
   }
   public void setWarnLogCategory(String loggerName) {
      this.warnLogger = LogFactory.getLog(loggerName);
   }

   //指定是否阻止此异常解析程序解析的任何视图的HTTP响应缓存。
   //默认值为false。 将其切换为true，以便自动生成抑制响应缓存的HTTP响应标头。
   public void setPreventResponseCaching(boolean preventResponseCaching) {
      this.preventResponseCaching = preventResponseCaching;
   }

   //检查是否应该应用此解析程序（即，所提供的处理程序是否与任何已配置的setMappedHandlers处理程序或setMappedHandlerClasses处理程序类匹配），
   //然后委托给doResolveException()模板方法。
   @Override
   @Nullable
   public ModelAndView resolveException(
         HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
      if (shouldApplyTo(request, handler)) {
         prepareResponse(ex, response);
         ModelAndView result = doResolveException(request, response, handler, ex);
         if (result != null) {
            // Print warn message when warn logger is not enabled...
            if (logger.isDebugEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {
               logger.debug("Resolved [" + ex + "]" + (result.isEmpty() ? "" : " to " + result));
            }
            // warnLogger with full stack trace (requires explicit config)
            logException(ex, request);
         }
         return result;
      }
      else {
         return null;
      }
   }

   //检查此解析程序是否应该应用于给定的处理程序。
   //默认实现检查配置的#setMappedHandlers处理程序和setMappedHandlerClasses处理程序类，如果有的话
   protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {
      if (handler != null) {
         if (this.mappedHandlers != null && this.mappedHandlers.contains(handler)) {
            return 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.
      return (this.mappedHandlers == null && this.mappedHandlerClasses == null);
   }
   protected void logException(Exception ex, HttpServletRequest request) {
      if (this.warnLogger != null && this.warnLogger.isWarnEnabled()) {
         this.warnLogger.warn(buildLogMessage(ex, request));
      }
   }
   protected String buildLogMessage(Exception ex, HttpServletRequest request) {
      return "Resolved [" + ex + "]";
   }

   //为特殊情况准备响应。
   //如果setPreventResponseCaching preventResponseCaching属性已设置为”true“，则默认实现会阻止响应被缓存
   protected void prepareResponse(Exception ex, HttpServletResponse response) {
      if (this.preventResponseCaching) {
         preventCaching(response);
      }
   }

   //通过设置相应的HTTP Cache-Control:no-store标头来阻止缓存响应。
   protected void preventCaching(HttpServletResponse response) {
      response.addHeader(HEADER_CACHE_CONTROL, "no-store");
   }

   //实际上解决了在处理程序执行期间抛出的给定异常，如果合适，返回表示特定错误页面的ModelAndView。
   //可以在子类中重写，以便应用特定的异常检查。
   //请注意，在检查此解析是否适用（“mappedHandlers”等）之后将调用此模板方法，因此实现可能只是继续其实际的异常处理。
   @Nullable
   protected abstract ModelAndView doResolveException(
         HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);

}

2、AbstractHandlerMethodExceptionResolver

HandlerExceptionResolver实现的抽象基类，支持处理类型为HandlerMethod的处理程序的异常。

public abstract class AbstractHandlerMethodExceptionResolver extends AbstractHandlerExceptionResolver {
   //检查处理程序是否为HandlerMethod，然后委托shouldApplyTo(HttpServletRequest,Object)
   //的基类实现传递HandlerMethod的bean。 否则返回false。
   @Override
   protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {
      if (handler == null) {
         return super.shouldApplyTo(request, null);
      }
      else if (handler instanceof HandlerMethod) {
         HandlerMethod handlerMethod = (HandlerMethod) handler;
         handler = handlerMethod.getBean();
         return super.shouldApplyTo(request, handler);
      }
      else {
         return false;
      }
   }

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

   //实际上解决了在处理程序执行期间抛出的给定异常，返回表示特定错误页面的ModelAndView（如果适用）。
   //可以在子类中重写，以便应用特定的异常检查。
   //请注意，在检查此解析是否适用（“mappedHandlers”等）之后将调用此模板方法，因此实现可能只是继续其实际的异常处理。
   @Nullable
   protected abstract ModelAndView doResolveHandlerMethodException(
         HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception ex);
}

3、ExceptionHandlerExceptionResolver

是一个AbstractHandlerMethodExceptionResolver，它通过@ExceptionHandler方法解决异常。可以通过setCustomArgumentResolvers()和setCustomReturnValueHandlers()添加对自定义参数和返回值类型的支持。
或者，重新配置所有参数和返回值类型使用setArgumentResolvers()和setReturnValueHandlers(List)。

@Override
public void afterPropertiesSet() {
   // Do this first, it may add ResponseBodyAdvice beans
   initExceptionHandlerAdviceCache();
   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);
   }
}

private void initExceptionHandlerAdviceCache() {
   if (getApplicationContext() == null) {
      return;
   }
   List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
   AnnotationAwareOrderComparator.sort(adviceBeans);
   for (ControllerAdviceBean adviceBean : adviceBeans) {
      Class<?> beanType = adviceBean.getBeanType();
      if (beanType == null) {
         throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
      }
      //可以处理@ExceptionHandler value属性值异常或异常处理方法参数指定的异常
      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");
      }
   }
}
//找到@ExceptionHandler方法并调用它来处理引发的异常
@Override
@Nullable
protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
      HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
   ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
   if (exceptionHandlerMethod == null) {
      return null;
   }
   if (this.argumentResolvers != null) {
  exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
   }
   if (this.returnValueHandlers != null) {  exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
   }
   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   ModelAndViewContainer mavContainer = new ModelAndViewContainer();
   try {
      if (logger.isDebugEnabled()) {
         logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
      }
      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) {
      // 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;
   }

   if (mavContainer.isRequestHandled()) {
      return new ModelAndView();
   }
   else {
      ModelMap model = mavContainer.getModel();
      HttpStatus status = mavContainer.getStatus();
      ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
      mav.setViewName(mavContainer.getViewName());
      if (!mavContainer.isViewReference()) {
         mav.setView((View) mavContainer.getView());
      }
      if (model instanceof RedirectAttributes) {
         Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
         RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
      }
      return mav;
   }
}
//找到给定异常的@ExceptionHandler方法。 
//默认实现首先搜索控制器的类层次结构中的方法，如果没有找到，它将继续搜索其他@ExceptionHandler方法，
//假设检测到一些@ControllerAdvice Spring管理的bean。
@Nullable
protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
      @Nullable HandlerMethod handlerMethod, Exception exception) {
   Class<?> handlerType = null;
   if (handlerMethod != null) {
      //控制器类本身的本地异常处理程序方法。
      //即使在基于接口的代理的情况下，也要通过代理调用。
      handlerType = handlerMethod.getBeanType();
      ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
      if (resolver == null) {
         resolver = new ExceptionHandlerMethodResolver(handlerType);
         this.exceptionHandlerCache.put(handlerType, resolver);
      }
      Method method = resolver.resolveMethod(exception);
      if (method != null) {
         return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
      }
      //对于下面的建议适用性检查（涉及基础包，可分配类型和注释存在），请使用目标类而不是基于接口的代理。
      if (Proxy.isProxyClass(handlerType)) {
         handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
      }
   }
   for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
      ControllerAdviceBean advice = entry.getKey();
      if (advice.isApplicableToBeanType(handlerType)) {
         ExceptionHandlerMethodResolver resolver = entry.getValue();
         Method method = resolver.resolveMethod(exception);
         if (method != null) {
            return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
         }
      }
   }
   return null;
}

4、ResponseStatusExceptionResolver

一个HandlerExceptionResolver，它使用@ResponseStatus注释将异常映射到HTTP状态代码。

默认情况下，在{@link org.springframework.web.servlet.DispatcherServlet DispatcherServlet}以及MVC Java配置和MVC命名空间中启用此异常解析程序。

从4.2开始，这个解析器也会以@ResponseStatus递归查找原因异常，从4.2.2开始，此解析器支持自定义组合注释中@ResponseStatus的属性覆盖。

从5.0开始，这个解析器也支持ResponseStatusException。

public class ResponseStatusExceptionResolver extends AbstractHandlerExceptionResolver implements MessageSourceAware {
   @Nullable
   private MessageSource messageSource;
   @Override
   public void setMessageSource(MessageSource messageSource) {
      this.messageSource = messageSource;
   }
   @Override
   @Nullable
   protected ModelAndView doResolveException(
         HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
      try {
         if (ex instanceof ResponseStatusException) {
            return resolveResponseStatusException((ResponseStatusException) ex, request, response, handler);
         }
         ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(ex.getClass(), ResponseStatus.class);
         if (status != null) {
            return resolveResponseStatus(status, request, response, handler, ex);
         }
         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;
   }

   //处理{@link ResponseStatus @ResponseStatus}注释的模板方法。
   //默认实现使用注释中的状态代码和原因委托给applyStatusAndReason()。
   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);
   }

   //处理{@link ResponseStatusException}的模板方法。
   //默认实现使用状态代码和异常原因委托给applyStatusAndReason()。
   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);
   }

   //将已解决的状态代码和原因应用于响应。
   //如果有原因，默认实现使用HttpServletResponse＃sendError(int)或HttpServletResponse＃sendError(int，String)发送响应错误，然后返回空的ModelAndView。
   protected ModelAndView applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response)
         throws IOException {
      if (!StringUtils.hasLength(reason)) {
         response.sendError(statusCode);
      }
      else {
         String resolvedReason = (this.messageSource != null ?
               this.messageSource.getMessage(reason, null, reason, LocaleContextHolder.getLocale()) :
               reason);
         response.sendError(statusCode, resolvedReason);
      }
      return new ModelAndView();
   }
}

5、DefaultHandlerExceptionResolver

HandlerExceptionResolver接口的默认实现，解析标准的Spring MVC异常并将它们转换为相应的HTTP状态代码。
默认情况下，在常见的Spring DispatcherServlet中启用此异常解析程序。