SpringMVC除了对请求URL的路由处理特别方便外，还支持对异常的统一处理机制，可以对业务操作时抛出的异常，unchecked异常以及状态码的异常进行统一处理。SpringMVC既提供简单的配置类，也提供了细粒度的异常控制机制。

SpringMVC中所有的异常处理通过接口HandlerExceptionResolver来实现，接口中只定义了一个方法

  1. public interface HandlerExceptionResolver {
  3.     ModelAndView resolveException(
  4.         HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex);
  5. }

方法中接受request和response信息，以及当前的处理Handler，和抛出的异常对象。并且提供抽象类AbstractHandlerExceptionResolver，实现resolveException方法，支持前置判断和处理，将实际处理抽象出doResolveException方法由子类来实现。

  1. @ControllerAdvice
  2. public class ExceptionAdvice {
  4.     @ExceptionHandler({ArrayIndexOutOfBoundsException.class})
  5.     @ResponseBody
  6.     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  7.     public ResponseDTO handleArrayIndexOutOfBoundsException(ArrayIndexOutOfBoundsException e) {
  8.         // TODO 记录log日志
  9.         e.printStackTrace();
  10.         ResponseDTO responseDTO = new ResponseDTO();
  11.         responseDTO.wrapResponse(ServiceCodeEnum.E999997, "数组越界异常");
  13.         return responseDTO;
  14.     }
  16.     @ExceptionHandler(value = ParamException.class)
  17.     @ResponseBody
  18.     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  19.     public ResponseDTO handleParamException(ParamException e) {
  20.         // TODO 记录log日志
  21.         e.printStackTrace();
  22.         ResponseDTO responseDTO = new ResponseDTO();
  23.         responseDTO.wrapResponse(ServiceCodeEnum.E999998, "输入参数错误");
  25.         return responseDTO;
  26.     }
  27.   
  28.     @ExceptionHandler({Exception.class})
  29.     @ResponseBody
  30.     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  31.     public ResponseDTO handleException(Exception e) {
  32.         // TODO 记录log日志
  33.         e.printStackTrace();
  34.         ResponseDTO responseDTO = new ResponseDTO();
  35.         responseDTO.wrapResponse(ServiceCodeEnum.E999999, "未知异常");
  36.         return responseDTO;
  37.     }
  39. }

我们看看 @ControllerAdvice

  1. @Target({ElementType.TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Component
  5. public @interface ControllerAdvice {
  6.     @AliasFor("basePackages")
  7.     String[] value() default {};
  9.     @AliasFor("value")
  10.     String[] basePackages() default {};
  12.     Class<?>[] basePackageClasses() default {};
  14.     Class<?>[] assignableTypes() default {};
  16.     Class<? extends Annotation>[] annotations() default {};
  17. }
  1. ControllerAdvice 被 @Component 修饰，则说明标记 @ControllerAdvice 会被扫描到容器中

Spring mvc 的配置如下(这里用到了mvc:annotation-driven)：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://cxf.apache.org/core"
  4.     xmlns:p="http://cxf.apache.org/policy" xmlns:ss="http://www.springframework.org/schema/security"
  5.     xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:jee="http://www.springframework.org/schema/jee"
  6.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  7.     xmlns:context="http://www.springframework.org/schema/context"
  8.     xmlns:mvc="http://www.springframework.org/schema/mvc"
  9.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
  10.     http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd 
  11.     http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd 
  12.     http://cxf.apache.org/policy http://cxf.apache.org/schemas/policy.xsd
  13.     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
  14.     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
  15.     http://cxf.apache.org/bindings/soap http://cxf.apache.org/schemas/configuration/soap.xsd 
  16.     http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd 
  17.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  18.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  19.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
  20.  
  21.     <context:component-scan
  22.         base-package="frame.web.controller;frame.web.advice" />
  23.  
  24.     <!--===================== view resovler ===================== -->
  25.     <bean id="jstlViewResolver"
  26.         class="org.springframework.web.servlet.view.UrlBasedViewResolver">
  27.         <property name="order" value="1" />
  28.         <property name="viewClass"
  29.             value="org.springframework.web.servlet.view.JstlView" />
  30.         <property name="prefix" value="/WEB-INF/jsp/" />
  31.     </bean>
  32.  
  33.     <mvc:annotation-driven/>
  34.  
  35.  
  36.     <!-- 自定义参数转换 -->
  37.     <bean id="conversionService"
  38.         class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
  39.     </bean>
  40.  
  41. </beans>
AnnotationDrivenBeanDefinitionParser类就是用于解析<mvc:annotation-drive>标签的。下面是AnnotationDrivenBeanDefinitionParser的部分源码：
  1. package org.springframework.web.servlet.config;
  3. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  5.     /**
  6.     *parse是这个类的核心方法，它用于解析 annotation-drive标签里的内容，根据标签里的内容往spring ioc容器里注入具体的对象。
  7.     **/
  8.     @Override
  9.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  10.         Object source = parserContext.extractSource(element);
  11.         XmlReaderContext readerContext = parserContext.getReaderContext();
  13.         CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
  14.         parserContext.pushContainingComponent(compDefinition);
  16.         RuntimeBeanReference contentNegotiationManager = getContentNegotiationManager(element, source, parserContext);
  17.         //这里有我们熟悉的RequestMappingHandlerMapping，
  18.         RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);
  19.         handlerMappingDef.setSource(source);
  20.         handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  21.         handlerMappingDef.getPropertyValues().add("order", 0);
  22.         handlerMappingDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
  24.         if (element.hasAttribute("enable-matrix-variables")) {
  25.             Boolean enableMatrixVariables = Boolean.valueOf(element.getAttribute("enable-matrix-variables"));
  26.             handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
  27.         }
  28.         else if (element.hasAttribute("enableMatrixVariables")) {
  29.             Boolean enableMatrixVariables = Boolean.valueOf(element.getAttribute("enableMatrixVariables"));
  30.             handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
  31.         }
  33.         configurePathMatchingProperties(handlerMappingDef, element, parserContext);
  34.         readerContext.getRegistry().registerBeanDefinition(HANDLER_MAPPING_BEAN_NAME , handlerMappingDef);
  36.         RuntimeBeanReference corsConfigurationsRef = MvcNamespaceUtils.registerCorsConfigurations(null, parserContext, source);
  37.         handlerMappingDef.getPropertyValues().add("corsConfigurations", corsConfigurationsRef);
  39.         //这里会注入具体的ConversionService用于将json,xml转成Spring mvc里的请求和返回对象
  40.         RuntimeBeanReference conversionService = getConversionService(element, source, parserContext);
  42.         RuntimeBeanReference validator = getValidator(element, source, parserContext);
  43.         RuntimeBeanReference messageCodesResolver = getMessageCodesResolver(element);
  45.         RootBeanDefinition bindingDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
  46.         bindingDef.setSource(source);
  47.         bindingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  48.         bindingDef.getPropertyValues().add("conversionService", conversionService);
  49.         bindingDef.getPropertyValues().add("validator", validator);
  50.         bindingDef.getPropertyValues().add("messageCodesResolver", messageCodesResolver);
  52.         ManagedList<?> messageConverters = getMessageConverters(element, source, parserContext);
  53.         ManagedList<?> argumentResolvers = getArgumentResolvers(element, parserContext);
  54.         ManagedList<?> returnValueHandlers = getReturnValueHandlers(element, parserContext);
  55.         String asyncTimeout = getAsyncTimeout(element);
  56.         RuntimeBeanReference asyncExecutor = getAsyncExecutor(element);
  57.         ManagedList<?> callableInterceptors = getCallableInterceptors(element, source, parserContext);
  58.         ManagedList<?> deferredResultInterceptors = getDeferredResultInterceptors(element, source, parserContext);
  59.         //RequestMappingHandlerAdapter也会在这里注入
  60.         RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
  61.         handlerAdapterDef.setSource(source);
  62.         handlerAdapterDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  63.         handlerAdapterDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
  64.         handlerAdapterDef.getPropertyValues().add("webBindingInitializer", bindingDef);
  65.         handlerAdapterDef.getPropertyValues().add("messageConverters", messageConverters);
  66.         addRequestBodyAdvice(handlerAdapterDef);
  67.         addResponseBodyAdvice(handlerAdapterDef);
  69.         if (element.hasAttribute("ignore-default-model-on-redirect")) {
  70.             Boolean ignoreDefaultModel = Boolean.valueOf(element.getAttribute("ignore-default-model-on-redirect"));
  71.             handlerAdapterDef.getPropertyValues().add("ignoreDefaultModelOnRedirect", ignoreDefaultModel);
  72.         }
  73.         else if (element.hasAttribute("ignoreDefaultModelOnRedirect")) {
  74.             // "ignoreDefaultModelOnRedirect" spelling is deprecated
  75.             Boolean ignoreDefaultModel = Boolean.valueOf(element.getAttribute("ignoreDefaultModelOnRedirect"));
  76.             handlerAdapterDef.getPropertyValues().add("ignoreDefaultModelOnRedirect", ignoreDefaultModel);
  77.         }
  79.         if (argumentResolvers != null) {
  80.             handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
  81.         }
  82.         if (returnValueHandlers != null) {
  83.             handlerAdapterDef.getPropertyValues().add("customReturnValueHandlers", returnValueHandlers);
  84.         }
  85.         if (asyncTimeout != null) {
  86.             handlerAdapterDef.getPropertyValues().add("asyncRequestTimeout", asyncTimeout);
  87.         }
  88.         if (asyncExecutor != null) {
  89.             handlerAdapterDef.getPropertyValues().add("taskExecutor", asyncExecutor);
  90.         }
  92.         handlerAdapterDef.getPropertyValues().add("callableInterceptors", callableInterceptors);
  93.         handlerAdapterDef.getPropertyValues().add("deferredResultInterceptors", deferredResultInterceptors);
  94.         readerContext.getRegistry().registerBeanDefinition(HANDLER_ADAPTER_BEAN_NAME , handlerAdapterDef);
  96.         String uriCompContribName = MvcUriComponentsBuilder.MVC_URI_COMPONENTS_CONTRIBUTOR_BEAN_NAME;
  97.         RootBeanDefinition uriCompContribDef = new RootBeanDefinition(CompositeUriComponentsContributorFactoryBean.class);
  98.         uriCompContribDef.setSource(source);
  99.         uriCompContribDef.getPropertyValues().addPropertyValue("handlerAdapter", handlerAdapterDef);
  100.         uriCompContribDef.getPropertyValues().addPropertyValue("conversionService", conversionService);
  101.         readerContext.getRegistry().registerBeanDefinition(uriCompContribName, uriCompContribDef);
  103.         RootBeanDefinition csInterceptorDef = new RootBeanDefinition(ConversionServiceExposingInterceptor.class);
  104.         csInterceptorDef.setSource(source);
  105.         csInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, conversionService);
  106.         RootBeanDefinition mappedCsInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);
  107.         mappedCsInterceptorDef.setSource(source);
  108.         mappedCsInterceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  109.         mappedCsInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, (Object) null);
  110.         mappedCsInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, csInterceptorDef);
  111.         String mappedInterceptorName = readerContext.registerWithGeneratedName(mappedCsInterceptorDef);
  113.         //这里有我们需要找的ExceptionHandlerExceptionResolver，
  114.         RootBeanDefinition exceptionHandlerExceptionResolver = new RootBeanDefinition(ExceptionHandlerExceptionResolver.class);
  115.         exceptionHandlerExceptionResolver.setSource(source);
  116.         exceptionHandlerExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  117.         exceptionHandlerExceptionResolver.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
  118.         exceptionHandlerExceptionResolver.getPropertyValues().add("messageConverters", messageConverters);
  119.         exceptionHandlerExceptionResolver.getPropertyValues().add("order", 0);
  120.         addResponseBodyAdvice(exceptionHandlerExceptionResolver);
  122.         if (argumentResolvers != null) {
  123.             exceptionHandlerExceptionResolver.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
  124.         }
  125.         if (returnValueHandlers != null) {
  126.             exceptionHandlerExceptionResolver.getPropertyValues().add("customReturnValueHandlers", returnValueHandlers);
  127.         }
  129.         String methodExceptionResolverName = readerContext.registerWithGeneratedName(exceptionHandlerExceptionResolver);
  131.         RootBeanDefinition responseStatusExceptionResolver = new RootBeanDefinition(ResponseStatusExceptionResolver.class);
  132.         responseStatusExceptionResolver.setSource(source);
  133.         responseStatusExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  134.         responseStatusExceptionResolver.getPropertyValues().add("order", 1);
  135.         String responseStatusExceptionResolverName =
  136.                 readerContext.registerWithGeneratedName(responseStatusExceptionResolver);
  138.         RootBeanDefinition defaultExceptionResolver = new RootBeanDefinition(DefaultHandlerExceptionResolver.class);
  139.         defaultExceptionResolver.setSource(source);
  140.         defaultExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  141.         defaultExceptionResolver.getPropertyValues().add("order", 2);
  142.         String defaultExceptionResolverName =
  143.                 readerContext.registerWithGeneratedName(defaultExceptionResolver);
  145.         parserContext.registerComponent(new BeanComponentDefinition(handlerMappingDef, HANDLER_MAPPING_BEAN_NAME));
  146.         parserContext.registerComponent(new BeanComponentDefinition(handlerAdapterDef, HANDLER_ADAPTER_BEAN_NAME));
  147.         parserContext.registerComponent(new BeanComponentDefinition(uriCompContribDef, uriCompContribName));
  148.         parserContext.registerComponent(new BeanComponentDefinition(exceptionHandlerExceptionResolver, methodExceptionResolverName));
  149.         parserContext.registerComponent(new BeanComponentDefinition(responseStatusExceptionResolver, responseStatusExceptionResolverName));
  150.         parserContext.registerComponent(new BeanComponentDefinition(defaultExceptionResolver, defaultExceptionResolverName));
  151.         parserContext.registerComponent(new BeanComponentDefinition(mappedCsInterceptorDef, mappedInterceptorName));
  153.         // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"
  154.         MvcNamespaceUtils.registerDefaultComponents(parserContext, source);
  156.         parserContext.popAndRegisterContainingComponent();
  158.         return null;
  159.     }
  160. }
通过上面代码的分析， 我们可以找到ExceptionHandlerExceptionResolver这个类来用于处理Spring MVC的各种异常，那ExceptionHandlerExceptionResolver具体又是如何跟ControllerAdvice配合使用来处理各种异常的呢?我们来看看ExceptionHandlerExceptionResolver里的关键代码：
  1. package org.springframework.web.servlet.mvc.method.annotation;
  3. //我们考到这个类实现了InitializingBean，则容器初始化的时候在实例化此Bean后会调用afterPropertiesSet()
  4. public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
  5.         implements ApplicationContextAware, InitializingBean {
  6.     //这里有个map用于保存ControllerAdviceBean和ExceptionHandlerMethodResolver
  7.     private final Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> exceptionHandlerAdviceCache =
  8.             new LinkedHashMap<ControllerAdviceBean, ExceptionHandlerMethodResolver>();
  10.     //这个方法是由spring 容器调用的
  11.     @Override
  12.     public void afterPropertiesSet() {
  13.         // Do this first, it may add ResponseBodyAdvice beans
  14.         //这个方法里会处理ExceptionHandler
  15.         initExceptionHandlerAdviceCache();
  17.         if (this.argumentResolvers == null) {
  18.             List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
  19.             this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
  20.         }
  21.         if (this.returnValueHandlers == null) {
  22.             List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
  23.             this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
  24.         }
  25.     }
  27.     /**
  28.     *这个方法里会在spring ioc容器里找出标注了@ControllerAdvice的类，如果有方法标注了@ExceptionHandler会生成一个ExceptionHandlerMethodResolver类用于处理异常并放到exceptionHandlerAdviceCache这个map缓存类里。
  29.     **/
  30.     private void initExceptionHandlerAdviceCache() {
  31.         if (getApplicationContext() == null) {
  32.             return;
  33.         }
  34.         if (logger.isDebugEnabled()) {
  35.             logger.debug("Looking for exception mappings: " + getApplicationContext());
  36.         }
  37.         //这里会找到容器里标注了@ControllerAdvice注解的类
  38.         List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
  39.         AnnotationAwareOrderComparator.sort(adviceBeans);
  41.         for (ControllerAdviceBean adviceBean : adviceBeans) {
  42.             //这个构造方法里会检查ControllerAdvice类里是否有@ExceptionHandler标注的方法，在ExceptionHandlerMethodResolver 有个异常的map。
  43.             //在ExceptionHandlerMethodResolver构造器中会通过反射拿到所有标注@ExceptionHandler的方法并加入ExceptionHandlerMethodResolver的map中
  44.             //key为  @ExceptionHandler(value = ParamException.class) 标注的value,这里就是ParamException.class，值为标注@ExceptionHandler的Method
  45.             ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(adviceBean.getBeanType());
  46.             if (resolver.hasExceptionMappings()) {
  47.                 //如果有@ExceptionHandler方法，会执行下面的逻辑
  48.                 //将标注@ControllerAdvice的类Bean，和此Bean中封装了所有Exception为key，Method为value的Map的ExceptionHandlerMethodResolver对象加入到exceptionHandlerAdviceCache的缓存中
  49.                 this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
  50.                 if (logger.isInfoEnabled()) {
  51.                     logger.info("Detected @ExceptionHandler methods in " + adviceBean);
  52.                 }
  53.             }
  54.             if (ResponseBodyAdvice.class.isAssignableFrom(adviceBean.getBeanType())) {
  55.                 this.responseBodyAdvice.add(adviceBean);
  56.                 if (logger.isInfoEnabled()) {
  57.                     logger.info("Detected ResponseBodyAdvice implementation in " + adviceBean);
  58.                 }
  59.             }
  60.         }
  61.     }
  63.     /**
  64.     ** 这个方法会根据exceptionHandlerAdviceCache这个找到具体需要处理异常的方法，这个后面再讲
  65.     */
  66.     protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) {
  67.         Class<?> handlerType = (handlerMethod != null ? handlerMethod.getBeanType() : null);
  69.         if (handlerMethod != null) {
  70.             ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
  71.             if (resolver == null) {
  72.                 resolver = new ExceptionHandlerMethodResolver(handlerType);
  73.                 this.exceptionHandlerCache.put(handlerType, resolver);
  74.             }
  75.             Method method = resolver.resolveMethod(exception);
  76.             if (method != null) {
  77.                 return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
  78.             }
  79.         }
  81.         for (Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
  82.             if (entry.getKey().isApplicableToBeanType(handlerType)) {
  83.                 ExceptionHandlerMethodResolver resolver = entry.getValue();
  84.                 //根据具体的异常找到处理异常的方法，然后调用
  85.                 Method method = resolver.resolveMethod(exception);
  86.                 if (method != null) {
  87.                     return new ServletInvocableHandlerMethod(entry.getKey().resolveBean(), method);
  88.                 }
  89.             }
  90.         }
  92.         return null;
  93.     }
  94. }

我们来看看 ExceptionHandlerMethodResolver这个类

  1. public class ExceptionHandlerMethodResolver {
  2.     public static final MethodFilter EXCEPTION_HANDLER_METHODS = new MethodFilter() {
  3.         public boolean matches(Method method) {
  4.             return AnnotationUtils.findAnnotation(method, ExceptionHandler.class) != null;
  5.         }
  6.     };
  7.     private static final Method NO_METHOD_FOUND = ClassUtils.getMethodIfAvailable(System.class, "currentTimeMillis", new Class[0]);
  8.     //此缓存Map存放了@ControllerAdvice中所有注解了@ExceptionHandler的方法，其中@ExceptionHandler的value也就是Exception做为Key，值为当前Method
  9.     private final Map<Class<? extends Throwable>, Method> mappedMethods = new ConcurrentHashMap(16);
  10.     private final Map<Class<? extends Throwable>, Method> exceptionLookupCache = new ConcurrentHashMap(16);
  12.     public ExceptionHandlerMethodResolver(Class<?> handlerType) {
  13.         //通过反射拿到当前Class的所有方法，也就是标注了@ControllerAdvice的所有方法
  14.         Iterator var2 = MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS).iterator();
  16.         //遍历所有的方法，寻找标注了@ExceptionHandler的方法
  17.         while(var2.hasNext()) {
  18.             Method method = (Method)var2.next();
  19.             //这里获取到标注了@ExceptionHandler的方法上所有的@ExceptionHandler中的value
  20.             //如{ArrayIndexOutOfBoundsException.class,ParamException.calss}
  21.             Iterator var4 = this.detectExceptionMappings(method).iterator();
  23.             while(var4.hasNext()) {
  24.                 Class<? extends Throwable> exceptionType = (Class)var4.next();
  25.                 //将ArrayIndexOutOfBoundsException.class作为key,method做为value加入到map缓存中
  26.                 this.addExceptionMapping(exceptionType, method);
  27.             }
  28.         }
  30.     }
  31.     
  32.     private List<Class<? extends Throwable>> detectExceptionMappings(Method method) {
  33.         List<Class<? extends Throwable>> result = new ArrayList();
  34.         //这里获取到标注了@ExceptionHandler的方法上所有的@ExceptionHandler中的value
  35.         //如{ArrayIndexOutOfBoundsException.class,ParamException.calss}
  36.         this.detectAnnotationExceptionMappings(method, result);
  37.         if (result.isEmpty()) {
  38.             Class[] var3 = method.getParameterTypes();
  39.             int var4 = var3.length;
  41.             for(int var5 = 0; var5 < var4; ++var5) {
  42.                 Class<?> paramType = var3[var5];
  43.                 if (Throwable.class.isAssignableFrom(paramType)) {
  44.                     result.add(paramType);
  45.                 }
  46.             }
  47.         }
  49.         Assert.notEmpty(result, "No exception types mapped to {" + method + "}");
  50.         return result;
  51.     }
  52.     
  53.     protected void detectAnnotationExceptionMappings(Method method, List<Class<? extends Throwable>> result) {
  54.         //判断此方法是否标记@ExceptionHandler，如果没有则返回null，如果有标记则返回ExceptionHandler
  55.         ExceptionHandler ann = (ExceptionHandler)AnnotationUtils.findAnnotation(method, ExceptionHandler.class);
  56.         //获取ExceptionHandler注解的所有值，这里是一个数组，有可能有多个，如@ExceptionHandler({ArrayIndexOutOfBoundsException.class,ParamException.calss})
  57.         result.addAll(Arrays.asList(ann.value()));
  58.     }
  60. }

SpringMVC怎么在请求处理的过程中完成对异常的统一处理的呢？我们从源码来深度解读。

回到DispatcherServlet的doDispatcher方法

  1. try {
  2.     processedRequest = checkMultipart(request);
  3.     multipartRequestParsed = (processedRequest != request);
  5.     // Determine handler for the current request.
  6.     mappedHandler = getHandler(processedRequest);
  7.     if (mappedHandler == null || mappedHandler.getHandler() == null) {
  8.         noHandlerFound(processedRequest, response);
  9.         return;
  10.     }
  12.     // Determine handler adapter for the current request.
  13.     HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  15.     if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  16.         return;
  17.     }
  19.     // Actually invoke the handler.
  20.     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  22.     if (asyncManager.isConcurrentHandlingStarted()) {
  23.         return;
  24.     }
  26.     applyDefaultViewName(processedRequest, mv);
  27.     mappedHandler.applyPostHandle(processedRequest, response, mv);
  28. }
  29. catch (Exception ex) {
  30.     dispatchException = ex;
  31. }
  32. catch (Throwable err) {
  33.     dispatchException = new NestedServletException("Handler dispatch failed", err);
  34. }
  35. processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

可以看到对请求处理的核心处理使用一个大的try/catch，如果出现异常，统一封装成dispatchException交给processDispatchResult方法进行处理。我们知道processDispatchResult方法用来对返回视图进行操作，而同时也对异常进行统一处理。

在processDispatchResult中，首先对异常进行判断。

  1. if (exception != null) {
  2.     if (exception instanceof ModelAndViewDefiningException) {
  3.         logger.debug("ModelAndViewDefiningException encountered", exception);
  4.         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
  5.     }
  6.     else {
  7.         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  8.         mv = processHandlerException(request, response, handler, exception);
  9.         errorView = (mv != null);
  10.     }
  11. }

如果不是特殊的ModelAndViewDefiningException，则由processHandlerException来操作。

  1. protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
  2.         Object handler, Exception ex) throws Exception {
  4.     // Check registered HandlerExceptionResolvers...
  5.     ModelAndView exMv = null;
  6.     // 遍历所有注册的异常处理器，由异常处理器进行处理
  7.     for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
  8.         exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
  9.         if (exMv != null) {
  10.             break;
  11.         }
  12.     }
  13.     // 如果异常视图存在，则转向异常视图
  14.     if (exMv != null) {
  15.         if (exMv.isEmpty()) {
  16.             request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
  17.             return null;
  18.         }
  19.         // We might still need view name translation for a plain error model...
  20.         if (!exMv.hasView()) {
  21.             exMv.setViewName(getDefaultViewName(request));
  22.         }
  23.         if (logger.isDebugEnabled()) {
  24.             logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);
  25.         }
  26.         WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
  27.         return exMv;
  28.     }
  30.     throw ex;
  31. }

我们主要关注异常处理器对异常的处理，SpringMVC通过HandlerExceptionResolver的resolveException调用实现类的实际实现方法doResolveException。

ExceptionHandlerExceptionResolver支持了@ExceptionHandler注解的实现。它的抽象基类AbstractHandlerMethodExceptionResolver继承了AbstractHandlerExceptionResolver，doResolveException方法实际调用ExceptionHandlerExceptionResolver的doResolveHandlerMethodException方法。

  1. protected final ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
  2.     return this.doResolveHandlerMethodException(request, response, (HandlerMethod)handler, ex);
  3. }
  5. protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
  6.         HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) {
  8.     // 根据HandlerMethod和exception获取异常处理的Method
  9.     ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
  10.     if (exceptionHandlerMethod == null) {
  11.         return null;
  12.     }
  14.     // 设置异常处理方法的参数解析器和返回值解析器
  15.     exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
  16.     exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
  18.     ServletWebRequest webRequest = new ServletWebRequest(request, response);
  19.     ModelAndViewContainer mavContainer = new ModelAndViewContainer();
  21.     // 执行异常处理方法
  22.     try {
  23.         if (logger.isDebugEnabled()) {
  24.             logger.debug("Invoking @ExceptionHandler method: " + exceptionHandlerMethod);
  25.         }
  26.         Throwable cause = exception.getCause();
  27.         if (cause != null) {
  28.             // Expose cause as provided argument as well
  29.             exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);
  30.         }
  31.         else {
  32.             // Otherwise, just the given exception as-is
  33.             exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);
  34.         }
  35.     }
  36.     catch (Throwable invocationEx) {
  37.         // Any other than the original exception is unintended here,
  38.         // probably an accident (e.g. failed assertion or the like).
  39.         if (invocationEx != exception && logger.isWarnEnabled()) {
  40.             logger.warn("Failed to invoke @ExceptionHandler method: " + exceptionHandlerMethod, invocationEx);
  41.         }
  42.         // Continue with default processing of the original exception...
  43.         return null;
  44.     }
  46.     // 对返回的视图模型进行处理
  47.     if (mavContainer.isRequestHandled()) {
  48.         return new ModelAndView();
  49.     }
  50.     else {
  51.         ModelMap model = mavContainer.getModel();
  52.         HttpStatus status = mavContainer.getStatus();
  53.         ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
  54.         mav.setViewName(mavContainer.getViewName());
  55.         if (!mavContainer.isViewReference()) {
  56.             mav.setView((View) mavContainer.getView());
  57.         }
  58.         if (model instanceof RedirectAttributes) {
  59.             Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
  60.             request = webRequest.getNativeRequest(HttpServletRequest.class);
  61.             RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
  62.         }
  63.         return mav;
  64.     }
  65. }

我们主要关注的是如何匹配到异常处理方法的，也就是 ExceptionHandlerExceptionResolver中的 getExceptionHandlerMethod

  1. protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) {
  2.     Class<?> handlerType = (handlerMethod != null ? handlerMethod.getBeanType() : null);
  4.     // 从当前Controller中匹配异常处理Method，此处我们暂时不分析
  5.     if (handlerMethod != null) {
  6.         ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
  7.         if (resolver == null) {
  8.             resolver = new ExceptionHandlerMethodResolver(handlerType);
  9.             this.exceptionHandlerCache.put(handlerType, resolver);
  10.         }
  11.         Method method = resolver.resolveMethod(exception);
  12.         if (method != null) {
  13.             return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
  14.         }
  15.     }
  17.     // 从ControllerAdvice中匹配异常处理Method
  18.     // 我们知道容器初始化的时候，已经寻找所有标注了@ControllerAdvice的类，并将此类标注了@ExceptionHandler的方法放到当前类的exceptionHandlerAdviceCache中
  19.     //遍历所有的@ControllerAdvice生成的缓存
  20.     for (Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
  21.         if (entry.getKey().isApplicableToBeanType(handlerType)) {
  22.             //拿到ExceptionHandlerMethodResolver，这个对象里包含了标注为@ExceptionHandler的Key为Excpthion，value为Method的缓存Map
  23.             ExceptionHandlerMethodResolver resolver = entry.getValue();
  24.             //寻找ExceptionHandlerMethodResolver有没有标注@ExceptionHandler能匹配当前异常的方法
  25.             Method method = resolver.resolveMethod(exception);
  26.             if (method != null) {
  27.                 return new ServletInvocableHandlerMethod(entry.getKey().resolveBean(), method);
  28.             }
  29.         }
  30.     }
  32.     return null;
  33. }
  35. public Method resolveMethod(Exception exception) {
  36.     Method method = this.resolveMethodByExceptionType(exception.getClass());
  37.     if (method == null) {
  38.         Throwable cause = exception.getCause();
  39.         if (cause != null) {
  40.             method = this.resolveMethodByExceptionType(cause.getClass());
  41.         }
  42.     }
  44.     return method;
  45. }
  47. public Method resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) {
  48.     //先从exceptionLookupCache缓存中拿，第一次肯定拿不到，因为我们是存在mappedMethods这个缓存中
  49.     Method method = (Method)this.exceptionLookupCache.get(exceptionType);
  50.     if (method == null) {
  51.         method = this.getMappedMethod(exceptionType);
  52.         this.exceptionLookupCache.put(exceptionType, method != null ? method : NO_METHOD_FOUND);
  53.     }
  55.     return method != NO_METHOD_FOUND ? method : null;
  56. }
  58. private Method getMappedMethod(Class<? extends Throwable> exceptionType) {
  59.     List<Class<? extends Throwable>> matches = new ArrayList();
  60.     //拿到所有的Key
  61.     Iterator var3 = this.mappedMethods.keySet().iterator();
  63.     while(var3.hasNext()) {
  64.         Class<? extends Throwable> mappedException = (Class)var3.next();
  65.         //判断exceptionType是不是mappedException本身或者其子类
  66.         if (mappedException.isAssignableFrom(exceptionType)) {
  67.             matches.add(mappedException);
  68.         }
  69.     }
  71.     if (!matches.isEmpty()) {
  72.         Collections.sort(matches, new ExceptionDepthComparator(exceptionType));
  73.         //返回匹配到异常的Method
  74.         return (Method)this.mappedMethods.get(matches.get(0));
  75.     } else {
  76.         return null;
  77.     }
  78. }

匹配到exceptionHandlerMethod后，设置一些方法执行的环境，然后调用ServletInvocableHandlerMethod中的invokeAndHandle去执行，这个调用过程和正常请求的调用就是一致了。

  1.   exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, new Object[]{exception, cause, handlerMethod});

这里就是调用异常处理的方法，总体来说，就是SpringMvc启动的时候初始化异常处理的组件，将 @ControllerAdvice标记的特殊类和@ExceptionHandler 标记的方法存入缓存中，当目标Controller出现异常的时候，就通过抛出的异常在缓存中找到对应的处理方法，然后去调用对应的异常处理方法就OK了。

 

版权声明：本文为java-chen-hao原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/java-chen-hao/p/11190659.html