Spring学习笔记(9)一springMVC全局异常处理

╰半夏微凉° 2022-09-26 00:29 153阅读 0赞

# 一、前言 #

--------------------

我们使用springboot做 Restfull API，希望能全局处理异常，返回自定义错误码。类似：

\{  "code":1001, "msg":"failed ..."｝

在springmvc基本思路就是定义定义全局异常处理器，返回相应的错误对象信息。其他方法如可以使用拦截器，或者filter。  
我们这里使用全局异常处理器  
springmvc实现全局异常一般使用两种方式：

1.  实现接口
2.  使用注解(比较简单)

我们先定义响应格式：

## 1、定义统一响应格式 ##

package com.demo.springmvc.response;
    
    public class ApiResponse {
        private String code;
        private String msg;
        private Object data;
    
        public ApiResponse() {
        }
        public ApiResponse(ResponseCode responseCode) {
            this.code = responseCode.getCode();
            this.msg = responseCode.getMsg();
        }
    
        public static ApiResponse getInstance(ResponseCode responseCode) {
            return new ApiResponse(responseCode);
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public Object getData() {
            return this.data;
        }
        public void setData(Object data) {
            this.data = data;
        }
    }

## 2、错误码枚举类 ##

自定义响应错误码：

package com.demo.springmvc.response;
    
    /**
     * Created by huangguisu on 2020/7/9.
     */
    public enum  ResponseCode {
    
        SUCCESS("0", "success"),//成功
        UNKNOWN_ERROR("999", "unkonwn error"),//未知错误
        TOKEN_ERROR("1001", "token error"),//token错误
        TEST1_ERROR("1002", "test1 error"),//test1错误
        TEST2_ERROR("1003", "test2 error");//test2错误
    
        /**
         * 结果码
         */
        private String code;
    
        /**
         * 结果码描述
         */
        private String msg;
    
        ResponseCode(String code, String msg) {
            this.code = code;
            this.msg = msg;
        }
        public String getCode() {
            return code;
        }
        public String getMsg() {
            return msg;
        }
    }

### 3、异常的表示形式：自定义业务异常类/接口 ###

异常一般可通过自定义异常类，或定义异常的信息接口，比如code，msg之类，然后通过一个统一的异常类进行封装。  
可以定义一个接口，该接口主要是方便后面的异常处理工具类实现

public interface BaseErrors {
        String getCode();
        String getMsg();
    }

BusinessException：

package com.demo.springmvc.exception;
    
    import com.demo.springmvc.response.ResponseCode;
    
    /**
     * 自定义业务异常
     * Created by huangguisu on 2019/7/9.
     */
    public class BusinessException  extends Exception implements BaseErrors{
        private String code;
        private String msg;
        private ResponseCode responseCode;
    
    
        public BusinessException(ResponseCode responseCode) {
            super(responseCode.getMsg());
            this.code = responseCode.getCode();
            this.msg = responseCode.getMsg();
            this.responseCode = responseCode;
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public ResponseCode getResponseCode() {
            return responseCode;
        }
    
        public void setResponseCode(ResponseCode responseCode) {
            this.responseCode = responseCode;
        }
        @Override
        public String getMessage() {
            return  "{" +
                    "\"code\":" + this.getCode() + ","+
                    "\"msg\":" + this.getMsg() + ","+
                    "}";
        }
    }

# 二、方式一：实现接口HandlerExceptionResolver #

--------------------

官方推荐的是使用@ExceptionHandler注解去捕获固定的异常，我们这只是为了演示,使用MappingJackson2JsonView类需要添加依赖才能实现返回响应json格式：

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.6.5</version>
    </dependency>

实现接口HandlerExceptionResolver：

package com.demo.springmvc.exception;
    
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.HandlerExceptionResolver;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
    import com.demo.springmvc.response.*;
    @Component
    public class ExceptionResolver implements HandlerExceptionResolver{
        @Override
        public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
            ModelAndView modelAndView = new ModelAndView(new MappingJackson2JsonView());
    
            //使用自定义BusinessException
            if (e instanceof BusinessException){
                modelAndView.addObject("code",((BusinessException) e).getCode());
                modelAndView.addObject("msg",((BusinessException) e).getMsg());
            }else {
                //未知的异常
                modelAndView.addObject("code", ResponseCode.UNKNOWN_ERROR.getCode());
                modelAndView.addObject("msg",ResponseCode.UNKNOWN_ERROR.getMsg());
    
            }
            return modelAndView;
        }
    }

抛出异常：

package com.demo.springmvc.controller;
    
    import org.springframework.web.bind.annotation.*;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import com.demo.springmvc.exception.BusinessException;
    import com.demo.springmvc.response.ResponseCode;
    @Controller
    @RequestMapping("/user")
    public class UserController {
        @RequestMapping("/")
        @ResponseBody
        public String index() {
            return "Hello world";
        }
    
        @RequestMapping("/exception")
        @ResponseBody
        public String testException() throws  Exception{
            ResponseCode responseCode = ResponseCode.TOKEN_ERROR;
            throw new BusinessException(responseCode);
        }
    }

部署后测试效果：

![20200709182447107.png][]

# 三、方式二：使用注解 #

--------------------

在spring 3.2中，新增了@ControllerAdvice 注解，可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，并应用到所有@RequestMapping中.

@ControllerAdvice：使用 @ControllerAdvice注解 的类的方法可以使用 @ExceptionHandler、 @InitBinder、 @ModelAttribute 注解到方法上，这对所有注解了 @RequestMapping 的控制器内的方法都有效。

@ExceptionHandler：需要处理的异常,如果不传值默认处理所有异常。  
@InitBinder：用来设置 WebDataBinder，WebDataBinder 用来自动绑定前台请求参数到 Model 中。  
@ModelAttribute：@ModelAttribute 本来的作用是绑定键值对到 Model 里，此处是让全局的@RequestMapping 都能获得在此处设置的键值对。

## 1、@ExceptionHandler单独使用： ##

1)、@ExceptionHandler单独使用,必须和要处理的方法在一个Controller类里面。这种配置方式处理的优先级最高，可以返回多种类型数据。  
2)、可以处理多类异常，如果不指定@ExceptionHandler的value，就处理所有Exception。  
3)、这种使用方式，代码侵入性高。

@RequestMapping("/exception1")
        @ResponseBody
        @ExceptionHandler({BusinessException.class})
        public String exception()throws  Exception {
            throw new BusinessException(ResponseCode.TEST1_ERROR);
    
        }
        @RequestMapping("/exception2")
        @ResponseBody
        @ExceptionHandler(value={Exception.class,BusinessException.class})
        public String exception2() throws  Exception{
            throw new BusinessException(ResponseCode.TEST2_ERROR);
        }

## 2、@ControllerAdvice + @ExceptionHandler方式全局 ##

定义全局异常处理类。

1.  通过 `@ControllerAdvice` 指定该类为 `Controller` 增强类。
2.  通过 `@ExceptionHandler` 自定捕获的异常类型。
3.  通过 `@ResponseBody` 返回 `json` 到前端。

这种配置方式可以在全局范围内处理异常,优先级仅次于单独使用@ExceptionHandler方式。该方式可以全局处理异常，处理逻辑灵活，最为推荐。

package com.demo.springmvc.exception;
    
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import com.demo.springmvc.response.*;
    
    @ControllerAdvice
    public class CommonException {
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public ApiResponse handleException(Exception e) {
            return ApiResponse.getInstance(ResponseCode.UNKNOWN_ERROR);
        }
    
        /**
         * 处理业务异常
         *
         * @param e 业务异常
         * @return apiResponse
         */
        @ExceptionHandler(BusinessException.class)
        @ResponseBody
        public ApiResponse handleOpdRuntimeException(BusinessException e) {
            return ApiResponse.getInstance(e.getResponseCode());
        }
    
    }

## **3、测试效果：** ##

**测试controller：**

package com.demo.springmvc.controller;
    
    import com.demo.springmvc.service.TestService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import com.demo.springmvc.exception.BusinessException;
    import com.demo.springmvc.response.ResponseCode;
    @Controller
    @RequestMapping("/user")
    
    public class UserController {
        @Autowired
        TestService testService;
    
        @RequestMapping("/exception")
        @ResponseBody
        public String testException() throws  Exception{
            ResponseCode responseCode = ResponseCode.TOKEN_ERROR;
            throw new BusinessException(responseCode);
        }
        @RequestMapping("/exception1")
        @ResponseBody
        //@ExceptionHandler({BusinessException.class})
        public String exception()throws  Exception {
            testService.testException1();
            return "";
    
        }
        @RequestMapping("/exception2")
        @ResponseBody
        //@ExceptionHandler(value={Exception.class,BusinessException.class})
        public String exception2() throws  Exception{
            testService.testException2();
            return "";
        }
    
    }

**service抛出异常：**

package com.demo.springmvc.service;
    
    import com.demo.springmvc.exception.BusinessException;
    import com.demo.springmvc.response.ResponseCode;
    import org.springframework.stereotype.Service;
    
    /**
     * Created by huangguisu on 2020/7/9.
     */
    @Service
    public class TestService {
    
        public void testException1(){
            throw new BusinessException(ResponseCode.TEST1_ERROR);
        }
        public void testException2(){
            throw new BusinessException(ResponseCode.TEST2_ERROR);
        }
    
    }

**如果springmvc项目测试不生效：  
1：检查包扫描路径是否对：<context:component-scan base-package="com.demo" /> 2  
2：是否添加激活注解模式：<mvc:annotation-driven/>**

![20200709194021723.png][]

[20200709182447107.png]: /images/20220717/868478cba69344218c672b01c286d3e8.png
[20200709194021723.png]: /images/20220717/686d23495e5a4d09939971237cd38fcb.png