SpringBoot优雅的全局异常处理

时间  2019-11-11
标签 springboot 优雅 全局 异常 处理 栏目 Spring 繁體版
原文   原文链接

前言

本篇文章主要介绍的是SpringBoot项目进行全局异常的处理。html

SpringBoot全局异常准备

说明：若是想直接获取工程那么能够直接跳到底部，经过连接下载工程代码。java

开发准备

环境要求
JDK：1.8
SpringBoot：1.5.17.RELEASEgit

首先仍是Maven的相关依赖:github

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.17.RELEASE</version>
        <relativePath />
    </parent>
    <dependencies>
        <!-- Spring Boot Web 依赖 核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
    </dependencies>

配置文件这块基本不须要更改，全局异常的处理只需在代码中实现便可。web

代码编写

SpringBoot的项目已经对有必定的异常处理了，可是对于咱们开发者而言可能就不太合适了，所以咱们须要对这些异常进行统一的捕获并处理。SpringBoot中有一个ControllerAdvice的注解，使用该注解表示开启了全局异常的捕获，咱们只需在自定义一个方法使用ExceptionHandler注解而后定义捕获异常的类型便可对这些捕获的异常进行统一的处理。spring

咱们根据下面的这个示例来看该注解是如何使用吧。json

示例代码:api

@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(value =Exception.class)
    public String exceptionHandler(Exception e){
        System.out.println("未知异常！缘由是:"+e);
        return e.getMessage();
    }
}

上述的示例中，咱们对捕获的异常进行简单的二次处理，返回异常的信息，虽然这种可以让咱们知道异常的缘由，可是在不少的状况下来讲，可能仍是不够人性化，不符合咱们的要求。
那么咱们这里能够经过自定义的异常类以及枚举类来实现咱们想要的那种数据吧。springboot

自定义基础接口类服务器

首先定义一个基础的接口类，自定义的错误描述枚举类需实现该接口。
代码以下:

public interface BaseErrorInfoInterface {
    /** 错误码*/
     String getResultCode();
    
    /** 错误描述*/
     String getResultMsg();
}

自定义枚举类

而后咱们这里在自定义一个枚举类，并实现该接口。
代码以下:

public enum CommonEnum implements BaseErrorInfoInterface {
    // 数据操做错误定义
    SUCCESS("200", "成功!"), 
    BODY_NOT_MATCH("400","请求的数据格式不符!"),
    SIGNATURE_NOT_MATCH("401","请求的数字签名不匹配!"),
    NOT_FOUND("404", "未找到该资源!"), 
    INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
    SERVER_BUSY("503","服务器正忙，请稍后再试!")
    ;

    /** 错误码 */
    private String resultCode;

    /** 错误描述 */
    private String resultMsg;

    CommonEnum(String resultCode, String resultMsg) {
        this.resultCode = resultCode;
        this.resultMsg = resultMsg;
    }

    @Override
    public String getResultCode() {
        return resultCode;
    }

    @Override
    public String getResultMsg() {
        return resultMsg;
    }

}

自定义异常类

而后咱们在来自定义一个异常类，用于处理咱们发生的业务异常。
代码以下:

public class BizException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    protected String errorCode;
    /**
     * 错误信息
     */
    protected String errorMsg;

    public BizException() {
        super();
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
        super(errorInfoInterface.getResultCode(), cause);
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    public BizException(String errorMsg) {
        super(errorMsg);
        this.errorMsg = errorMsg;
    }
    
    public BizException(String errorCode, String errorMsg) {
        super(errorCode);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public BizException(String errorCode, String errorMsg, Throwable cause) {
        super(errorCode, cause);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }
    

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public String getMessage() {
        return errorMsg;
    }

    @Override
    public Throwable fillInStackTrace() {
        return this;
    }

}

自定义数据格式

顺便这里咱们定义一下数据的传输格式。
代码以下:

public class ResultBody {
    /**
     * 响应代码
     */
    private String code;

    /**
     * 响应消息
     */
    private String message;

    /**
     * 响应结果
     */
    private Object result;

    public ResultBody() {
    }

    public ResultBody(BaseErrorInfoInterface errorInfo) {
        this.code = errorInfo.getResultCode();
        this.message = errorInfo.getResultMsg();
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

    /**
     * 成功
     * 
     * @return
     */
    public static ResultBody success() {
        return success(null);
    }

    /**
     * 成功
     * @param data
     * @return
     */
    public static ResultBody success(Object data) {
        ResultBody rb = new ResultBody();
        rb.setCode(CommonEnum.SUCCESS.getResultCode());
        rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
        rb.setResult(data);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultBody error(BaseErrorInfoInterface errorInfo) {
        ResultBody rb = new ResultBody();
        rb.setCode(errorInfo.getResultCode());
        rb.setMessage(errorInfo.getResultMsg());
        rb.setResult(null);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultBody error(String code, String message) {
        ResultBody rb = new ResultBody();
        rb.setCode(code);
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultBody error( String message) {
        ResultBody rb = new ResultBody();
        rb.setCode("-1");
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }

}

自定义全局异常处理类

最后咱们在来编写一个自定义全局异常处理的类。
代码以下:

@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    /**
     * 处理自定义的业务异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value = BizException.class)  
    @ResponseBody  
    public  ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){
        logger.error("发生业务异常！缘由是：{}",e.getErrorMsg());
        return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
    }

    /**
     * 处理空指针的异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value =NullPointerException.class)
    @ResponseBody
    public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){
        logger.error("发生空指针异常！缘由是:",e);
        return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
    }


    /**
        * 处理其余异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value =Exception.class)
    @ResponseBody
    public ResultBody exceptionHandler(HttpServletRequest req, Exception e){
        logger.error("未知异常！缘由是:",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }
}

由于这里咱们只是用于作全局异常处理的功能实现以及测试，因此这里咱们只需在添加一个实体类和一个控制层类便可。

实体类

又是万能的用户表 (^▽^)

代码以下：

public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    /** 编号 */
     private int id;
     /** 姓名 */
     private String name;
     /** 年龄 */
     private int age;
     
     public User(){
     }

    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

Controller 控制层

控制层这边也比较简单，使用Restful风格实现的CRUD功能，不一样的是这里我故意弄出了一些异常，好让这些异常被捕获到而后处理。这些异常中，有自定义的异常抛出，也有空指针的异常抛出，固然也有不可预知的异常抛出(这里我用类型转换异常代替)，那么咱们在完成代码编写以后，看看这些异常是否可以被捕获处理成功吧！

代码以下:

@RestController
@RequestMapping(value = "/api")
public class UserRestController {

    @PostMapping("/user")
    public boolean insert(@RequestBody User user) {
        System.out.println("开始新增...");
        //若是姓名为空就手动抛出一个自定义的异常！
        if(user.getName()==null){
            throw  new BizException("-1","用户姓名不能为空！");
        }
        return true;
    }

    @PutMapping("/user")
    public boolean update(@RequestBody User user) {
        System.out.println("开始更新...");
       //这里故意形成一个空指针的异常，而且不进行处理
        String str=null;
        str.equals("111");
        return true;
    }

    @DeleteMapping("/user")
    public boolean delete(@RequestBody User user)  {
        System.out.println("开始删除...");
        //这里故意形成一个异常，而且不进行处理
        Integer.parseInt("abc123");
        return true;
    }

    @GetMapping("/user")
    public List<User> findByUser(User user) {
        System.out.println("开始查询...");
        List<User> userList =new ArrayList<>();
        User user2=new User();
        user2.setId(1L);
        user2.setName("xuwujing");
        user2.setAge(18);
        userList.add(user2);
        return userList;
    }
    
}

App 入口

和普通的SpringBoot项目基本同样。

代码以下:

@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
        System.out.println("程序正在运行...");
    }
}

功能测试

咱们成功启动该程序以后，使用Postman工具来进行接口测试。

首先进行查询，查看程序正常运行是否ok，使用GET 方式进行请求。

GET http://localhost:8181/api/user

返回参数为:

{"id":1,"name":"xuwujing","age":18}

示例图:
在这里插入图片描述
能够看到程序正常返回，并无因自定义的全局异常而影响。

而后咱们再来测试下自定义的异常是否可以被正确的捕获并处理。

使用POST方式进行请求

POST http://localhost:8181/api/user

Body参数为:

{"id":1,"age":18}

返回参数为:

{"code":"-1","message":"用户姓名不能为空！","result":null}

示例图:
在这里插入图片描述
能够看出将咱们抛出的异常进行数据封装，而后将异常返回出来。

而后咱们再来测试下空指针异常是否可以被正确的捕获并处理。在自定义全局异常中，咱们除了定义空指针的异常处理，也定义最高级别之一的Exception异常，那么这里发生了空指针异常以后，它是回优先使用哪个呢？这里咱们来测试下。

使用PUT方式进行请求。

PUT http://localhost:8181/api/user

Body参数为:

{"id":1,"age":18}

返回参数为:

{"code":"400","message":"请求的数据格式不符!","result":null}

示例图:

咱们能够看到这里的的确是返回空指针的异常护理，能够得出全局异常处理优先处理子类的异常。

那么咱们在来试试未指定其异常的处理，看该异常是否可以被捕获。

使用DELETE方式进行请求。

DELETE http://localhost:8181/api/user

Body参数为:

{"id":1}

返回参数为:

{"code":"500","message":"服务器内部错误!","result":null}

在这里插入图片描述

这里能够看到它使用了咱们在自定义全局异常处理类中的Exception异常处理的方法。
到这里，测试就结束了。顺便再说一下，自义定全局异常处理除了能够处理上述的数据格式以外，也能够处理页面的跳转，只需在新增的异常方法的返回处理上填写该跳转的路径并不使用ResponseBody 注解便可。 细心的同窗也许发现了在GlobalExceptionHandler类中使用的是ControllerAdvice注解，而非RestControllerAdvice注解，若是是用的RestControllerAdvice注解，它会将数据自动转换成JSON格式，这种于Controller和RestController相似，因此咱们在使用全局异常处理的以后能够进行灵活的选择处理。

其它

关于SpringBoot优雅的全局异常处理的文章就讲解到这里了，若有不妥，欢迎指正！

项目地址

SpringBoot全局异常的处理项目工程地址:
https://github.com/xuwujing/springBoot-study/tree/master/springboot-exceptionHandler

SpringBoot整个集合的地址:
https://github.com/xuwujing/springBoot-study

SpringBoot整合系列的文章

音乐推荐

原创不易，若是感受不错，但愿给个推荐！您的支持是我写做的最大动力！ 版权声明: 做者：虚无境 博客园出处：http://www.cnblogs.com/xuwujing CSDN出处：http://blog.csdn.net/qazwsxpcm　　　　 我的博客出处：http://www.panchengming.com

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程