springmvc异常处理解析#ExceptionHandlerExceptionResolver

开头

试想一下我们一般怎么统一处理异常呢，答：切面。但抛开切面不讲，如果对每一个controller方法抛出的异常做专门处理，那么着实太费劲了，有没有更好的方法呢？当然有，就是本篇文章接下来要介绍的springmvc的异常处理机制，用到了ControllerAdvice和ExceptionHandler注解，有点切面的感觉哈哈。
 
1.ExceptionHandlerExceptionResolver

首先从springmvc的异常处理解析器开始讲，当执行完controller方法后，不管有没有异常产生都会调用DispatcherServlet#doDispatch()方法中的processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); 方法，接着会判断是否有异常，若无异常则走正常流程，若有异常则需要进行处理 mv = processHandlerException(request, response, handler, exception);  再接着就是遍历spring已经注册的异常处理解析器直到有处理器返回mav

1. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
2.                         @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
3.                         @Nullable Exception exception) throws Exception {
5.                 if (exception != null) {
6.                         if (exception instanceof ModelAndViewDefiningException) {
7.                                 logger.debug("ModelAndViewDefiningException encountered", exception);
8.                                 mv = ((ModelAndViewDefiningException) exception).getModelAndView();
9.                         }
10.                         else {
11.                                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
12.                                 // 执行处理器产生的异常处理
13.                                 mv = processHandlerException(request, response, handler, exception);
14.                                 // 是否有异常视图返回
15.                                 errorView = (mv != null);
16.                         }
17.                 }
19.                 // Did the handler return a view to render? 处理程序是否返回要渲染的视图
20.                 if (mv != null && !mv.wasCleared()) {
21.                         // 渲染视图
22.                         render(mv, request, response);
23.                         if (errorView) {
24.                                 WebUtils.clearErrorRequestAttributes(request);
25.                         }
26.                 }
27.                 else {
28.                         if (logger.isDebugEnabled()) {
29.                                 logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
30.                                                 "': assuming HandlerAdapter completed request handling");
31.                         }
32.                 }
33.         }

复制代码

1.         @Nullable
2.         protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
3.                         @Nullable Object handler, Exception ex) throws Exception {
5.                 // Check registered HandlerExceptionResolvers...
6.                 ModelAndView exMv = null;
7.                 if (this.handlerExceptionResolvers != null) {
8.                         for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
9.                                 exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
10.                                 if (exMv != null) {
11.                                         break;
12.                                 }
13.                         }
14.                 }
15.                 if (exMv != null) {
16.                         // 无视图view
17.                         if (exMv.isEmpty()) {
18.                                 request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
19.                                 return null;
20.                         }
21.                         // We might still need view name translation for a plain error model...
22.                         if (!exMv.hasView()) {
23.                                 String defaultViewName = getDefaultViewName(request);
24.                                 if (defaultViewName != null) {
25.                                         exMv.setViewName(defaultViewName);
26.                                 }
27.                         }
28.                         WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
29.                         return exMv;
30.                 }
32.                 throw ex;
33.         }

复制代码

 
其中最重要也是最常使用的一个处理器就是ExceptionHandlerExceptionResolver，下面将着重介绍它，先来看看这个类的继承结构图，实现了InitializingBean接口，在这个bean创建完成之前会调用生命周期初始化方法afterPropertiesSet（），这里面包含了对@ControllerAdvice注解的解析，初始化完后的信息供后续解析异常使用。

实现HandlerExceptionResolver接口，实现解析方法resolveException()

1. public interface HandlerExceptionResolver {
3.         /**
4.          * Try to resolve the given exception that got thrown during handler execution,
5.          * returning a {@link ModelAndView} that represents a specific error page if appropriate.
6.          * <p>The returned {@code ModelAndView} may be {@linkplain ModelAndView#isEmpty() empty}
7.          * to indicate that the exception has been resolved successfully but that no view
8.          * should be rendered, for instance by setting a status code.
9.          * @param request current HTTP request
10.          * @param response current HTTP response
11.          * @param handler the executed handler, or {@code null} if none chosen at the
12.          * time of the exception (for example, if multipart resolution failed)
13.          * @param ex the exception that got thrown during handler execution
14.          * @return a corresponding {@code ModelAndView} to forward to,
15.          * or {@code null} for default processing in the resolution chain
16.          */
17.         @Nullable
18.         ModelAndView resolveException(
19.                         HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
21. }

复制代码

1. @Override
2. public void afterPropertiesSet() {
3.     // Do this first, it may add ResponseBodyAdvice beans
4.     // 初始化异常注解 @ControllerAdvice
5.     initExceptionHandlerAdviceCache();
6. }
8. private void initExceptionHandlerAdviceCache() {
9.     if (getApplicationContext() == null) {
10.         return;
11.     }
12.     if (logger.isDebugEnabled()) {
13.         logger.debug("Looking for exception mappings: " + getApplicationContext());
14.     }
16.     // 解析有@ControllerAdvice注解的bean，并将这个bean构建成ControllerAdviceBean对象
17.     List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
18.     // 将ControllerAdviceBean根据order排序
19.     AnnotationAwareOrderComparator.sort(adviceBeans);
21.     for (ControllerAdviceBean adviceBean : adviceBeans) {
22.         Class<?> beanType = adviceBean.getBeanType();
23.         if (beanType == null) {
24.             throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
25.         }
26.         ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
27.         // mappedMethods 映射不为空
28.         if (resolver.hasExceptionMappings()) {
29.             // 添加到缓存中
30.             this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
31.             if (logger.isInfoEnabled()) {
32.                 logger.info("Detected @ExceptionHandler methods in " + adviceBean);
33.             }
34.         }
35.         // 若实现了ResponseBodyAdvice接口（暂不介绍）
36.         if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
37.             this.responseBodyAdvice.add(adviceBean);
38.             if (logger.isInfoEnabled()) {
39.                 logger.info("Detected ResponseBodyAdvice implementation in " + adviceBean);
40.             }
41.         }
42.     }
43. }

复制代码

 ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType); 这行代码会解析拥有@ControllerAdvice 注解的class，并且会遍历class中带有 @ExceptionHandler 注解的方法，获取方法注解带有的异常类型，将异常类型和方法放入到mappedMethods中供后面获取，获取的时候若对应处理此异常类型的method有多个，则需要进行排序，选取一个异常类型与method ExceptionHandler注解异常类型最近的一个（深度最小的那个也即是继承关系最少的那个）具体代码如下：
ExceptionHandlerMethodResolver

1. public class ExceptionHandlerMethodResolver {
3.         /**
4.          * A filter for selecting {@code @ExceptionHandler} methods.
5.          */
6.         public static final MethodFilter EXCEPTION_HANDLER_METHODS = method ->
7.                         (AnnotationUtils.findAnnotation(method, ExceptionHandler.class) != null);
10.         /**
11.          * 异常类型与方法的映射map
12.          */
13.         private final Map<Class<? extends Throwable>, Method> mappedMethods = new HashMap<>(16);
15.         /**
16.          * 缓存，用来存储先前碰到过的异常类型与处理方法的映射
17.          */
18.         private final Map<Class<? extends Throwable>, Method> exceptionLookupCache = new ConcurrentReferenceHashMap<>(16);
21.         /**
22.          * A constructor that finds {@link ExceptionHandler} methods in the given type.
23.          * @param handlerType the type to introspect
24.          */
25.         public ExceptionHandlerMethodResolver(Class<?> handlerType) {
26.                 // 获取并遍历@ExceptionHandler注解的方法
27.                 for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
28.                         for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
29.                                 addExceptionMapping(exceptionType, method);
30.                         }
31.                 }
32.         }
35.         /**
36.          * Extract exception mappings from the {@code @ExceptionHandler} annotation first,
37.          * and then as a fallback from the method signature itself.
38.          */
39.         @SuppressWarnings("unchecked")
40.         private List<Class<? extends Throwable>> detectExceptionMappings(Method method) {
41.                 List<Class<? extends Throwable>> result = new ArrayList<>();
42.                 // 将注解ExceptionHandler value值异常添加到result中
43.                 detectAnnotationExceptionMappings(method, result);
44.                 // 注解值为空的话再去获取参数的异常类型
45.                 if (result.isEmpty()) {
46.                         for (Class<?> paramType : method.getParameterTypes()) {
47.                                 if (Throwable.class.isAssignableFrom(paramType)) {
48.                                         result.add((Class<? extends Throwable>) paramType);
49.                                 }
50.                         }
51.                 }
52.                 if (result.isEmpty()) {
53.                         throw new IllegalStateException("No exception types mapped to " + method);
54.                 }
55.                 return result;
56.         }
58.         protected void detectAnnotationExceptionMappings(Method method, List<Class<? extends Throwable>> result) {
59.                 ExceptionHandler ann = AnnotationUtils.findAnnotation(method, ExceptionHandler.class);
60.                 Assert.state(ann != null, "No ExceptionHandler annotation");
61.                 result.addAll(Arrays.asList(ann.value()));
62.         }
64.         private void addExceptionMapping(Class<? extends Throwable> exceptionType, Method method) {
65.                 // 将异常类型以及对应的method添加到map中，且异常类型不能有重复否则会报错
66.                 Method oldMethod = this.mappedMethods.put(exceptionType, method);
67.                 if (oldMethod != null && !oldMethod.equals(method)) {
68.                         throw new IllegalStateException("Ambiguous @ExceptionHandler method mapped for [" +
69.                                         exceptionType + "]: {" + oldMethod + ", " + method + "}");
70.                 }
71.         }
73.         /**
74.          * Whether the contained type has any exception mappings.
75.          */
76.         public boolean hasExceptionMappings() {
77.                 return !this.mappedMethods.isEmpty();
78.         }
80.         /**
81.          * Find a {@link Method} to handle the given exception.
82.          * Use {@link ExceptionDepthComparator} if more than one match is found.
83.          * @param exception the exception
84.          * @return a Method to handle the exception, or {@code null} if none found
85.          */
86.         @Nullable
87.         public Method resolveMethod(Exception exception) {
88.                 return resolveMethodByThrowable(exception);
89.         }
91.         /**
92.          * Find a {@link Method} to handle the given Throwable.
93.          * Use {@link ExceptionDepthComparator} if more than one match is found.
94.          * @param exception the exception
95.          * @return a Method to handle the exception, or {@code null} if none found
96.          * @since 5.0
97.          */
98.         @Nullable
99.         public Method resolveMethodByThrowable(Throwable exception) {
100.                 Method method = resolveMethodByExceptionType(exception.getClass());
101.                 if (method == null) {
102.                         Throwable cause = exception.getCause();
103.                         if (cause != null) {
104.                                 method = resolveMethodByExceptionType(cause.getClass());
105.                         }
106.                 }
107.                 return method;
108.         }
110.         /**
111.          * Find a {@link Method} to handle the given exception type. This can be
112.          * useful if an {@link Exception} instance is not available (e.g. for tools).
113.          * @param exceptionType the exception type
114.          * @return a Method to handle the exception, or {@code null} if none found
115.          */
116.         @Nullable
117.         public Method resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) {
118.                 Method method = this.exceptionLookupCache.get(exceptionType);
119.                 if (method == null) {
120.                         method = getMappedMethod(exceptionType);
121.                         this.exceptionLookupCache.put(exceptionType, method);
122.                 }
123.                 return method;
124.         }
126.         /**
127.          * Return the {@link Method} mapped to the given exception type, or {@code null} if none.
128.          */
129.         @Nullable
130.         private Method getMappedMethod(Class<? extends Throwable> exceptionType) {
131.                 List<Class<? extends Throwable>> matches = new ArrayList<>();
132.                 for (Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {
133.                         if (mappedException.isAssignableFrom(exceptionType)) {
134.                                 matches.add(mappedException);
135.                         }
136.                 }
137.                 if (!matches.isEmpty()) {
138.                         // exceptionType 到matchs父类异常类型的深度
139.                         matches.sort(new ExceptionDepthComparator(exceptionType));
140.                         return this.mappedMethods.get(matches.get(0));
141.                 }
142.                 else {
143.                         return null;
144.                 }
145.         }
147. }

复制代码

exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod); 此方法执行完成后已经完成了异常处理方法的调用，若方法返回值为视图ModelAndView或其他视图类型，则还需要借助视图解析器如InternalResourceViewResolver对视图进行解析渲染，若为其他类型的值则将值写入到response响应中。
 
2. demo

Controller类方法：

1. @Override
2. @Nullable
3. protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
4.                                                        HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
6.     // exception为controller方法抛出的异常
7.     // 根据异常及其类型从上述的mappedMethods中获取对应的方法，再获取方法所在的对象 封装成ServletInvocableHandlerMethod
8.     ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
9.     if (exceptionHandlerMethod == null) {
10.         return null;
11.     }
13.     // 设置参数解析器，主要用来获取方法的参数值的，供后续反射调用方法
14.     if (this.argumentResolvers != null) {
15.         exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
16.     }
17.     // 设置返回值解析器，当执行完方法后获取返回值，对返回值进行处理 或返回视图或将结果写入到response
18.     if (this.returnValueHandlers != null) {
19.         exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
20.     }
22.     ServletWebRequest webRequest = new ServletWebRequest(request, response);
23.     ModelAndViewContainer mavContainer = new ModelAndViewContainer();
25.     try {
26.         if (logger.isDebugEnabled()) {
27.             logger.debug("Invoking @ExceptionHandler method: " + exceptionHandlerMethod);
28.         }
29.         Throwable cause = exception.getCause();
30.         if (cause != null) {
31.             // Expose cause as provided argument as well
32.             // 执行异常处理方法，也就是我们的自定义的异常处理方法
33.             exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);
34.         }
35.         else {
36.             // Otherwise, just the given exception as-is
37.             exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);
38.         }
39.     }
40.     catch (Throwable invocationEx) {
41.         // Any other than the original exception is unintended here,
42.         // probably an accident (e.g. failed assertion or the like).
43.         if (invocationEx != exception && logger.isWarnEnabled()) {
44.             logger.warn("Failed to invoke @ExceptionHandler method: " + exceptionHandlerMethod, invocationEx);
45.         }
46.         // Continue with default processing of the original exception...
47.         return null;
48.     }
50.     // 根据后续的返回值解析器设置的，将返回值写入到response中了直接返回空的mav
51.     if (mavContainer.isRequestHandled()) {
52.         return new ModelAndView();
53.     }
54.     else {
55.         ModelMap model = mavContainer.getModel();
56.         HttpStatus status = mavContainer.getStatus();
57.         ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
58.         mav.setViewName(mavContainer.getViewName());
59.         // (this.view instanceof String)
60.         if (!mavContainer.isViewReference()) {
61.             mav.setView((View) mavContainer.getView());
62.         }
63.         if (model instanceof RedirectAttributes) {
64.             Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
65.             RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
66.         }
67.         return mav;
68.     }
69. }

复制代码

ExceptionHandlerController异常处理类

1. @Controller
2. @RequestMapping(value = "test")
3. public class HelloWorldController{
5.   @Data
6.   public static class User {
7.     private String username;
9.     private Integer age;
11.     private String address;
12.   }
15.   @RequestMapping(value = "user/get", method = RequestMethod.POST)
16.   @ResponseBody
17.   public Object testObject(@RequestBody @Valid User user, @RequestParam String address) {
18.     user.setAddress(address);
19.     // 这里特意抛出RuntimeException异常
20.     throw new RuntimeException("this is a exception");
21.   }
23. }

复制代码

ExceptionHandlerController类中定义了两个异常处理方法，一个处理Exception异常，一个处理RuntimeException异常，那个根据controller方法抛出的异常RuntimeException再结合上面的分析（RuntimeException到RuntimeException深度为0，RuntimeException到Exception中间继承了一次深度为1）可以得出抛出异常类型的处理方法为handlerRuntimeException 方法。 运行程序结果如下：

 
结语

初步解析ExceptionHandlerExceptionResolver源码，若写的有误或者有不理解的地方，欢迎指出讨论~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！