Spring 异常处理三种方式

亦凉 2023-10-02 16:36 37阅读 0赞

## Spring 异常处理三种方式 ##

1.  异常处理方式一. @ExceptionHandler
2.  异常处理方式二. 实现HandlerExceptionResolver接口
3.  异常处理方式三. @ControllerAdvice+@ExceptionHandler
4.  三种方式比较说明(强烈推荐各位看一下，我觉得自己总结的比较多，嘿嘿，不对之处请指出)

#### 文章目录 ####

*  Spring 异常处理三种方式
 *   *  问题描述: 假如对异常不进行处理？
 *  异常处理的方式有三种:
 *   *  一. Controller层面上异常处理 @ExceptionHandler
     *   *  原理说明：
     *  二. 全局级别异常处理器 实现HandlerExceptionResolver接口
     *   *  原理分析：
     *  三.全局级别异常处理器 @ControllerAdvice+@ExceptionHandler
     *  四.比较说明.

### 问题描述: 假如对异常不进行处理？ ###

假如SpringMvc我们不对异常进行任何处理, 界面上显示的是这样的.

[![image][]][image 1]

## 异常处理的方式有三种: ##

### 一. Controller层面上异常处理 @ExceptionHandler ###

说明:针对可能出问题的Controller，新增注解方法@ExceptionHandler.

@Controller
    @RequestMapping("/testController")
    public class TestController {
        
     
        @RequestMapping("/demo1")
        @ResponseBody
        public Object demo1(){
        
            int i = 1 / 0;
            return new Date();
        }
     
        @ExceptionHandler({
        RuntimeException.class})
        public ModelAndView fix(Exception ex){
        
            System.out.println("do This");
            return new ModelAndView("error",new ModelMap("ex",ex.getMessage()));
        }
    }

注意事项:

1.  一个Controller下多个@ExceptionHandler上的异常类型不能出现一样的，否则运行时抛异常.  
    Ambiguous @ExceptionHandler method mapped for;
2.  @ExceptionHandler下方法返回值类型支持多种，常见的ModelAndView，@ResponseBody注解标注，ResponseEntity等类型都OK.

#### 原理说明： ####

代码片段位于:org.springframework.web.servlet.DispatcherServlet\#doDispatch

执行@RequestMapping方法抛出异常后，Spring框架 try-catch的方法捕获异常, 正常逻辑发不发生异常都会走processDispatchResult流程 ，区别在于异常的参数是否为null .

HandlerExecutionChain mappedHandler = null;
        Exception dispatchException = null;
        ModelAndView mv = null;
        try{
        
             
            mappedHandler=getHandler(request); //根据请求查找handlerMapping找到controller
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());//找到处理器适配器HandlerAdapter
             
            if(!mappedHandler.applyPreHandle(request,response)){
         //拦截器preHandle
                return ;
            }       
            mv=ha.handle(request,response); //调用处理器适配器执行@RequestMapping方法
            mappedHandler.applyPostHandle(request,response,mv);  //拦截器postHandle
        }catch(Exception ex){
        
            dispatchException=ex;
        }
            processDispatchResult(request,response,mappedHandler,mv,dispatchException) //将异常信息传入了

代码片段位于：org.springframework.web.servlet.DispatcherServlet\#processDispatchResult

如果@RequestMapping方法抛出异常，拦截器的postHandle方法不执行，进入 processDispatchResult，判断入参 dispatchException，不为null , 代表发生异常，调用processHandlerException处理,

[![image][image 2]][image_image 2]

代码片段位于:org.springframework.web.servlet.DispatcherServlet\#processHandlerException

this当前对象指dispatchServlet,handlerExceptionResolvers可以看到有三个HandlerExceptionResolver, 这三个是<mvc:annotation-driven />帮我们注册的. 遍历有序集合handlerExceptionResolvers，调用接口的resolveException方法.

[![image][image 3]][image_image 3]

记录mvc:annotation-driven/注册的第一个 HandlerExceptionResolver : ExceptionHandlerExceptionResolver, 继承关系如下面所示.

[![image][image 4]][image_image 4]

代码片段位于:org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver\#resolveException

AbstractHandlerExceptionResolver 和 AbstractHandlerMethodExceptionResolver名字看起来非常相似. 这里AbstractHandlerExceptionResolver 的shouldApplyTo都返回 true, logException用来记录日志、prepareResponse方法用来设置response的Cache-Control. 异常处理方法就位于doResolveException.

[![image][image 5]][image_image 5]

代码片段位于:org.springframework.web.servlet.handler.AbstractHandlerMethodExceptionResolver\#shouldApplyTo

接口方法实现是AbstractHandlerExceptionResolver的resolveException，先判断 shouldApplyTo, AbstractHandlerExceptionResolver 和子类AbstractHandlerMethodExceptionResolver都实现了shouldApplyTo方法，子类的shouldApplyTo都调用父类AbstractHandlerExceptionResolver的shouldApplyTo.

[![image][image 6]][image_image 6]

查看父类AbstractHandlerExceptionResolver的shouldApplyTo方法.

代码片段位于:org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver\#shouldApplyTo

Spring初始化的时候并没有额外配置 , 所以mappedHandlers和mappedHandlerClasses都为null, 可以在这块扩展进行筛选 ，AbstractHandlerExceptionResolver提供了 setMappedHandlerClasses 、setMappedHandlers用于扩展.

[![image][image 7]][image_image 7]

代码片段位于：org.springframework.web.servlet.handler.AbstractHandlerMethodExceptionResolver\#doResolveException

[![image][image 8]][image_image 8]

代码片段位于:org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver\#doResolveHandlerMethodException

似曾相识的ServletInvocableHandlerMethod，**getExceptionHandlerMethod**目的就是获取 针对异常的处理方法，没找到的话这里就直接返回了，找到了执行异常处理方法;

之后同Spring请求方法执行一样的处理方式，设置argumentResolvers、returnValueHandlers，之后进行调用异常处理方法，

**@ExceptionHandler的方法入参支持：Exception ；SessionAttribute 、 RequestAttribute注解 ； HttpServletRequest 、HttpServletResponse、HttpSession.**

**@ExceptionHandler方法返回值常见的可以是: ModelAndView 、@ResponseBody注解、ResponseEntity;**

[![image][image 9]][image_image 9]

**getExceptionHandlerMethod说明： 获取对应的@ExceptionHandler方法，封装成ServletInvocableHandlerMethod返回.**

代码片段位于:org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver\#getExceptionHandlerMethod

**exceptionHandlerCache是针对Controller层面的@ExceptionHandler的处理方式，而exceptionHandlerAdviceCache是针对@ControllerAdvice的处理方式. 这两个属性都位于ExceptionHandlerExceptionResolver中.**

handlerType指代Controller的class属性，尝试从**缓存A** exceptionHandlerCache 中根据controller的class 查找ExceptionHandlerMethodResolver； **缓存A**之前没存储过Controller的class ，所以新建一个ExceptionHandlerMethodResolver 加入缓存中. ExceptionHandlerMethodResolver 的初始化工作一定做了某些工作!

resolveMethod方法：根据异常对象让 ExceptionHandlerMethodResolver 解析得到 method ， 匹配到异常处理方法 就直接封装成对象 ServletInvocableHandlerMethod ； 就不会再去走@ControllerAdvice里的异常处理器了. 这里说明了，ExceptionHandlerMethodResolver 初始化的时候完成存储 @ExceptionHandler.

[![image][image 10]][image_image 10]

**查看ExceptionHandlerMethodResolver 初始化工作内容:**

代码片段位于:org.springframework.web.method.annotation.ExceptionHandlerMethodResolver\#ExceptionHandlerMethodResolver

handlerType为传入的Controller的class属性，通过EXCEPTION\_HANDLER\_METHODS选出 class 中标注@ExceptionHandler的方法，解析@Exception注解的value值(class类型的数组)，并加入到当前ExceptionHandlerMethodResolver的mappedMethods集合中，key为 异常类型 ，value为 method.

**如果@ExceptionHandler的 value属性为空，就会将方法入参中的Throwable的子类作为异常类型. @ExceptionHandler的value属性和方法入参不能同时都为空，否则会抛出异常.**

[![image][image 11]][image_image 11]

[![image][image 12]][image_image 12]

[![image][image 13]][image_image 13]

[![image][image 14]][image_image 14]

**ExceptionHandlerMethodResolver完成了初始化工作，如何根据当前发生异常类型查找到对应方法?**

代码片段位于:org.springframework.web.method.annotation.ExceptionHandlerMethodResolver\#resolveMethod

**resolveMethodByExceptionType**根据当前抛出异常寻找 匹配的方法，并且做了缓存，以后遇到同样的异常可以直接走缓存取出method，

[![image][image 15]][image_image 15]

代码片段位于:org.springframework.web.method.annotation.ExceptionHandlerMethodResolver\#resolveMethodByExceptionType

**resolveMethodByExceptionType**方法，尝试从**缓存A**：exceptionLookupCache中根据 异常class类型获取Method ，初始时候肯定缓存为空 ，就去 遍历ExceptionHandlerMethodResolver的mappedMethods(上面提及了key为异常类型，value为method), exceptionType为当前@RequestMapping方法抛出的异常，判断当前异常类型是不是@ExceptionHandler中value声明的子类或本身，满足条件就代表匹配上了；可能存在多个匹配的方法，使用ExceptionDepthComparator排序，排序规则是按照继承顺序来(继承关系越靠近数值越小，当前类最小为0,顶级父类Throwable为int最大值)，排序之后选取继承关系最靠近的那个，并且存入ExceptionHandlerMethodResolver的exceptionLookupCache中，key为当前抛出的异常，value为解析出来的匹配method.

[![image][image 16]][image_image 16]

至此 @ExceptionHandler Spring读取到并解析出来完毕了，后续流程和Spring正常请求流程一样，包括@ExceptionHandler的方法入参、方法返回值.

**@ExceptionHandler的方法入参支持：Exception ；SessionAttribute 、 RequestAttribute注解 ； HttpServletRequest 、HttpServletResponse、HttpSession.**

**@ExceptionHandler方法返回值常见的可以是: ModelAndView 、@ResponseBody注解、ResponseEntity;**

### 二. 全局级别异常处理器 实现HandlerExceptionResolver接口 ###

使用方式： **只需要将该Bean加入到Spring容器，可以通过Xml配置，也可以通过注解方式加入容器;**

**方法返回值不为null才有意义，如果方法返回值为null，可能异常就没有被捕获.**

缺点分析：比如这种方式全局异常处理返回JSP、velocity等视图比较方便，返回json或者xml等格式的响应就需要自己实现了.如下是我实现的发生全局异常返回JSON的简单例子.

public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
        
     
        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        
            System.out.println("发生全局异常!");
            ModelMap mmp=new ModelMap();
            mmp.addAttribute("ex",ex.getMessage());
            response.addHeader("Content-Type","application/json;charset=UTF-8");
            try {
        
                new ObjectMapper().writeValue(response.getWriter(),ex.getMessage());
                response.getWriter().flush();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
            return new ModelAndView();
        }
     
    }

#### 原理分析： ####

记得之前介绍了 DispatcherServlet的HandlerExceptionResolver集合，这种方式的HandlerExceptionResolver就是从DispatcherServlet的HandlerExceptionResolver集合入手的.

代码片段位于:org.springframework.web.servlet.DispatcherServlet\#processHandlerException

this对象指代DispatcherServlet，和上面方式对比，发现我们只是将MyHandlerExceptionResolver 加入到Spring容器，dispatchServlet 的 handlerExceptionResolvers属性就多了我们自己定义的全局异常解析器；

ExceptionHandlerMethodResolver是用来解析@Controller层面的@ExceptionHandler注解，当前Controller没有找到@ExceptionHandler来处理自己抛出的异常，才遍历下一个HandlerExceptionResolver；

**HandlerExceptionResolver是个有序集合，Spring注册的HandlerExceptionResolver调用resolveException都失败之后，才轮到我们自定义的MyHandlerExceptionResolver ；而且我们自定义的MyHandlerExceptionResolver 就没法使用SpringMvc的注解等等.**

[![image][image 17]][image_image 17]

**我们只是将HandlerExceptionResolver加入到Spring容器中,Spring是如何通知给DispatcherServlet呢?**

代码片段位于:org.springframework.web.servlet.DispatcherServlet\#initHandlerExceptionResolvers

**initHandlerExceptionResolvers只是DispatcherServlet初始化策略方法initStrategies中的一小步，可以看到只要是SpringMvc父子容器中注册的HandlerExceptionResolver类型实例，DispatcherServlet都会自动将其加入到DispatcherServlet的handlerExceptionResolvers中. 所以我们需要做的只是实现HandlerExceptionResolver接口，并且纳入Spring容器管理即可.**

[![image][image 18]][image_image 18]

### 三.全局级别异常处理器 @ControllerAdvice+@ExceptionHandler ###

简单使用方法：

@ControllerAdvice
    public class GlobalController {
        
     
        @ExceptionHandler(RuntimeException.class)
        public ModelAndView fix1(Exception e){
        
            System.out.println("全局的异常处理器");
            ModelMap mmp=new ModelMap();
            mmp.addAttribute("ex",e);
            return new ModelAndView("error",mmp);
        }
    }

package com.abc.admin;
    
    import com.github.pagehelper.Page;
    import com.viready.scpms.pojo.bean.ResponseResult;
    import org.springframework.core.MethodParameter;
    import org.springframework.http.MediaType;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    @ControllerAdvice
    public class ControllerAdviceHandler implements ResponseBodyAdvice<Object> {
        
    
     
        @ResponseBody
        @ExceptionHandler(value = Throwable.class)
        public ResponseResult catchAllError(HttpServletRequest request, HttpServletResponse response, Throwable error) {
        
            return ResponseResult.exception(error);
        }
    
        @Override
        public boolean supports(MethodParameter method, Class<? extends HttpMessageConverter<?>> clazz) {
        
            return method.getContainingClass().getPackage().getName().startsWith("com.abc") &&
                    (method.getContainingClass().getAnnotation(RestController.class) != null ||
                            (method.getMethod() != null && method.getMethod().getAnnotation(ResponseBody.class) != null));
        }
    
        @Override
        public Object beforeBodyWrite(Object result, MethodParameter methodParameter, MediaType mediaType,
                                      Class<? extends HttpMessageConverter<?>> aClass,
                                      ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        
            return result instanceof ResponseResult ? result :
                    result instanceof Page ? ResponseResult.page((Page<?>) result) :
                            ResponseResult.successData(result);
        }
    }

用法说明: **这种情况下 @ExceptionHandler 与第一种方式用法相同，返回值支持ModelAndView，@ResponseBody等多种形式.**

**方式一提到ExceptionHandlerExceptionResolver不仅维护@Controller级别的@ExceptionHandler，同时还维护的@ControllerAdvice级别的@ExceptionHandler.**

代码片段位于：org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver\#getExceptionHandlerMethod

isApplicableToBeanType方法是用来做条件判断的，@ControllerAdvice注解有很多属性用来设置条件，basePackageClasses、assignableTypes、annotations等，比如我限定了annotations为注解X， 那标注了@X 的ControllerA就可以走这个异常处理器，ControllerB就不能走这个异常处理器.

现在问题的关键就只剩下了exceptionHandlerAdviceCache是什么时候扫描@ControllerAdvice的，下面的逻辑和@ExceptionHandler的逻辑一样了.

[![image][image 19]][image_image 19]

**exceptionHandlerAdviceCache初始化逻辑:**

代码片段位于:org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver\#afterPropertiesSet

afterPropertiesSet是Spring bean创建过程中一个重要环节.

[![image][image 20]][image_image 20]

代码片段位于:org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver\#initExceptionHandlerAdviceCache

ControllerAdviceBean.findAnnotatedBeans方法查找了SpringMvc父子容器中标注 @ControllerAdvice 的bean, new ExceptionHandlerMethodResolver初始化时候解析了当前的@ControllerAdvice的bean的@ExceptionHandler,加入到**ExceptionHandlerExceptionResolver**的**exceptionHandlerAdviceCache**中，key为ControllerAdviceBean，value为ExceptionHandlerMethodResolver . 到这里exceptionHandlerAdviceCache就初始化完毕.

[![image][image 21]][image_image 21]

**查找SpringMvc父子容器中所有@ControllerAdivce的bean的方法**

代码片段位于：org.springframework.web.method.ControllerAdviceBean\#findAnnotatedBeans

遍历了SpringMVC父子容器中所有的bean，标注ControllerAdvice注解的bean加入集合返回.

[![image][image 22]][image_image 22]

### 四.比较说明. ###

@Controller+@ExceptionHandler、HandlerExceptionResolver接口形式、@ControllerAdvice+@ExceptionHandler优缺点说明：

在Spring4.3.0版本下，

1.优先级来说，@Controller+@ExceptionHandler优先级最高，其次是@ControllerAdvice+@ExceptionHandler，最后才是HandlerExceptionResolver，说明假设三种方式并存的情况 优先级越高的越先选择，而且被一个捕获处理了就不去执行其他的.

2. 三种方式都支持多种返回类型，@Controller+@ExceptionHandler、@ControllerAdvice+@ExceptionHandler可以使用Spring支持的@ResponseBody、ResponseEntity，而HandlerExceptionResolver方法声明返回值类型只能是 ModelAndView，如果需要返回JSON、xml等需要自己实现.

3.缓存利用，@Controller+@ExceptionHandler的缓存信息在**ExceptionHandlerExceptionResolver的**exceptionHandlerCache，@ControllerAdvice+@ExceptionHandler的缓存信息在**ExceptionHandlerExceptionResolver的exceptionHandlerAdviceCache**中, 而HandlerExceptionResolver接口是不做缓存的，在前面两种方式都fail的情况下才会走自己的HandlerExceptionResolver实现类，多少有点性能损耗.

**EOF**

![img][]

[image]: https://img-blog.csdnimg.cn/img_convert/e6f4caa4c31693157bd8b0ae173255cc.png
[image 1]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213505335-1513644054.png
[image 2]: https://img-blog.csdnimg.cn/img_convert/91ff519f95e3b0b8cffe6a55d93d8274.png
[image_image 2]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213505888-2030203515.png
[image 3]: https://img-blog.csdnimg.cn/img_convert/ae937930434f8871de5182f3eb2606de.png
[image_image 3]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213506844-1654136479.png
[image 4]: https://img-blog.csdnimg.cn/img_convert/bbee321f09685de325986054207b0892.png
[image_image 4]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213507487-117467346.png
[image 5]: https://img-blog.csdnimg.cn/img_convert/f9162099708523304dc61284dbf32305.png
[image_image 5]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213508459-1480757473.png
[image 6]: https://img-blog.csdnimg.cn/img_convert/4b4c760bc7ae537afe9ed738b8383f64.png
[image_image 6]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213509235-794344844.png
[image 7]: https://img-blog.csdnimg.cn/img_convert/7d21692fb47ba0c42b70ead7933b5d86.png
[image_image 7]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213510217-865137658.png
[image 8]: https://img-blog.csdnimg.cn/img_convert/3e238a58ba6dc915f9983a52b7ee1323.png
[image_image 8]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213511032-81051857.png
[image 9]: https://img-blog.csdnimg.cn/img_convert/ec0272b48edfbcbd148f665457560629.png
[image_image 9]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213512288-1219310442.png
[image 10]: https://img-blog.csdnimg.cn/img_convert/142eb9ae8e9dbbb9cbff16480bc3040d.png
[image_image 10]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213513211-1902635389.png
[image 11]: https://img-blog.csdnimg.cn/img_convert/97eac9610d2dce86b7610c4eb26bfc63.png
[image_image 11]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213513873-799885182.png
[image 12]: https://img-blog.csdnimg.cn/img_convert/5ff916148c5ce3c3d04183c1fcbfc7f8.png
[image_image 12]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213514484-626305684.png
[image 13]: https://img-blog.csdnimg.cn/img_convert/b3a19705f7c87159eb1c69a9afed3bd3.png
[image_image 13]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213515127-1489936418.png
[image 14]: https://img-blog.csdnimg.cn/img_convert/2a270ee78a44eef7745de71a1e763a80.png
[image_image 14]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213515732-1845386764.png
[image 15]: https://img-blog.csdnimg.cn/img_convert/642eb2d130d87373e9db94308ac6119b.png
[image_image 15]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213516357-941731817.png
[image 16]: https://img-blog.csdnimg.cn/img_convert/24a8705235e7ec34fb5b9a33ea433a3a.png
[image_image 16]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213517347-1230556380.png
[image 17]: https://img-blog.csdnimg.cn/img_convert/cec23b97d9026ea961fb7b8a6956ec5e.png
[image_image 17]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213518226-1400160846.png
[image 18]: https://img-blog.csdnimg.cn/img_convert/26fe6593c879a1e8ca0251ed047d4628.png
[image_image 18]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213519385-76841028.png
[image 19]: https://img-blog.csdnimg.cn/img_convert/42c9755689123b89dd4edf58d1897331.png
[image_image 19]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213520405-253670661.png
[image 20]: https://img-blog.csdnimg.cn/img_convert/75c6dbea06ed153b27f4a6708f843aee.png
[image_image 20]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213521107-576988204.png
[image 21]: https://img-blog.csdnimg.cn/img_convert/a7f8629bacc58645531c52ff1a350407.png
[image_image 21]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213522102-1856948808.png
[image 22]: https://img-blog.csdnimg.cn/img_convert/63b14ad039b0576f341416c97d3a6c63.png
[image_image 22]: https://img2018.cnblogs.com/blog/1550387/201903/1550387-20190321213523591-764129054.png
[img]: https://img-blog.csdnimg.cn/img_convert/78cc81812c9e1bf3ccca054bf1a3db38.gif