SpringBoot中的全局异常处理

本文主要介绍SpringBoot的全局异常处理，包括异常信息的封装、异常信息的捕获和处理，以及在实际项目中，我们用到的自定义异常和业务异常的捕获和处理

---

1.定义返回的统一json结构

前端或者其他服务请求本服务的接口时，该接口需要返回对应的json数据，一般该服务只需要返回请求者需要的参数即可，但是在实际项目中，我们需要封装更多的信息，比如状态码code、相关信息msg等。这里我们只保留状态码code和异常信息msg

package com.example.springdemo1.util;

public class JsonResult {
    private String code;//状态码
    private String msg;//请求信息

    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 JsonResult() {
        this.code="200";
        this.msg="操作成功";
    }

    public JsonResult(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

2.处理系统异常

新建一个GlobalExceptionHandler全局异常处理类，然后加上@COntrollerAdvice注解即可拦截项目中抛出的异常

package com.example.springdemo1.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    //打印log
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    //.......
}

我们点开@ControllerAdvice注解可以看到，@ControllerAdvice注解包含了@Component注解，说明在SpringBoot启动时，也会把该类作为组件交给Spring来管理，除此之外，该注解还有个basePackages属性，该属性是用来拦截哪个包中的异常信息，一般我们不指定这个属性，我们拦截项目中所有异常，@ResponseBody注解是为了异常处理完之后给调用方输出一个json格式的封装数据。
在项目中如何使用呢？SpringBoot中很简单，在方法上通过@ExceptionHandler注解来指定具体的异常，然后在方法中处理该异常信息，最后将结果通过统一的json结构体返回给调用者

2.1 处理参数缺失异常

参数缺失的时候，会抛出HttpMessageNotReadableException，我们可以拦截该异常，做一个友好处理，如下：

package com.example.springdemo1.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    //打印log
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    //.......
    public JsonResult handleHttpMessageNotReadableException(MissingServletRequestParameterException ex){
        logger.error("缺少请求参数,{}",ex.getMessage());
        return new JsonResult("400","缺少必要的参数");
    }
}

我们来写个简单的Controller测试一下该异常，通过POST请求方式接收两个参数：姓名和密码

package com.example.springdemo1.controller;

import com.example.springdemo1.util.JsonResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class testController8 {
    private static final Logger logger = LoggerFactory.getLogger(testController8.class);

    @PostMapping("/testException")
    public JsonResult testException(@RequestParam("name") String name,@RequestParam("passWord") String passWord){
        logger.info("name:{}",name);
        logger.info("passWord:{}",passWord);
        return new JsonResult();
    }
}

然后使用Postman来调用一下该接口，调用的时候，只传姓名，不传密码，就会抛缺少参数异常，该异常被捕获后，就会进入我们写好的逻辑，给调用方返回一个友好信息

2.2 处理空指针异常

容易出现空指针异常的场景：

• （1）解析json的过程中可能会出现空指针异常，所以我们在通过jsonObject去获取相关信息时，应该先做非空判断
• （2）从数据库中查询的数据，不管是查询一条记录封装在某个对象中，还是查询多条记录封装在一个List中，我们接下来都要去处理数据，那么就有可能出现空指针异常

对空指针异常的处理很简单，和上面的逻辑一样，将异常信息换掉即可

package com.example.springdemo1.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MissingServletRequestParameterException;
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.ResponseStatus;

@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    //打印log
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    //.......
    @ExceptionHandler(MissingServletRequestParameterException.class)
    @ResponseStatus(value= HttpStatus.BAD_REQUEST)
    public JsonResult handleHttpMessageNotReadableException(MissingServletRequestParameterException ex){
        logger.error("缺少请求参数,{}",ex.getMessage());
        return new JsonResult("400","缺少必要的参数");
    }

    @ExceptionHandler(NullPointerException.class)
    @ResponseStatus(value= HttpStatus.INTERNAL_SERVER_ERROR)
    public JsonResult handleTypeMismatchException(NullPointerException ex){
        logger.error("空指针异常,{}",ex.getMessage());
        return new JsonResult("500","空指针异常了");
    }
}

2.3 直接拦截Exception异常

异常很多，比如还有RuntimeException，数据库还有一些查询或者操作异常等，由于Exception异常时父类，所有异常都会继承该异常，所以我们可以直接拦截Exception异常，一劳永逸

    @ExceptionHandler(Exception.class)
    @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
    public JsonResult handleUnexpectedServer(Exception ex){
        logger.error("系统异常：",ex);
        return new JsonResult("500","系统异常");
    }

2.4 小结

项目中，我们一般都会比较详细的去拦截一些常见异常，拦截Exception虽然可以一劳永逸，但是不利于我们去排查或者定位问题，实际项目中，可以吧拦截Exception异常写在GlobalExceptionHandler最下面，如果都没有找到，最后再拦截一下Exception异常，保证输出信息友好。

3.拦截自定义异常

使用场景：要处理一个服务的调用时，那么可能会调用失败或者调用超时等等，此时我们需要自定义一个异常，当调用失败时抛出该异常，给GlobalExceptionHandler去捕获

3.1 定义异常信息

由于在业务中，有很多异常，针对不同的业务，可能给出的提示信息不同，所以为了方便项目异常信息管理，自定义一个异常信息枚举类

package com.example.springdemo1.util;

public enum BusinessMsgEnum {
    //参数异常
    PARMETER_EXCEPTION("102","参数异常！"),
    //等待超时
    SERVICE_TIME_OUT("103","服务调用超时！"),
    //参数过大
    PARMETER_BIG_EXCEPTION("102","输入的图片数量不能超过50张！"),
    //500：Exception的提示也可以在这定义
    UNEXPECTED_EXCEPTION("500","系统异常");
    //还可以定义更多的业务异常
    private String code;//消息码
    private String msg;//消息内容

    private BusinessMsgEnum(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    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;
    }
}

3.2 拦截自定义异常

定义一个业务异常，当出现业务异常时，我们就抛这个自定义的业务异常即可，比如定义一个BusinessErrorException异常。

package com.example.springdemo1.util;

public class BusinessErrorException extends RuntimeException{
    private static final long serialVersionUid = -7480022450501760611L;
    private String code;
    private String message;
    public BusinessErrorException(BusinessMsgEnum businessMsgEnum){
        this.code = businessMsgEnum.getCode();
        this.message = businessMsgEnum.getCode();
    }

    public static long getSerialVersionUid() {
        return serialVersionUid;
    }

    public String getCode() {
        return code;
    }

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

    @Override
    public String getMessage() {
        return message;
    }

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

在构造方法中，传入我们上面自定义的异常枚举类，所以在项目中，如果有新的异常信息需要添加，我们直接在枚举类中添加即可，很方便，做到统一维护，然后再拦截该异常时获取即可

package com.example.springdemo1.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MissingServletRequestParameterException;
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.ResponseStatus;

@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    //打印log
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    @ExceptionHandler(BusinessErrorException.class)
    @ResponseStatus(value=HttpStatus.INTERNAL_SERVER_ERROR)
    public JsonResult handleBusinessError(BusinessErrorException ex){
        String code = ex.getCode();
        String message = ex.getMessage();
        return new JsonResult(code,message);
    }
}

在业务中，我们可以直接模拟一下抛出业务异常，测试一下

package com.example.springdemo1.controller;

import com.example.springdemo1.util.BusinessErrorException;
import com.example.springdemo1.util.BusinessMsgEnum;
import com.example.springdemo1.util.JsonResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class testController9 {
    private static final Logger logger = LoggerFactory.getLogger(testController9.class);
    
    @GetMapping("/business")
    public JsonResult testException(){
        try{
            int x = 1 / 0;
        }catch(Exception e){
            throw new BusinessErrorException(BusinessMsgEnum.UNEXPECTED_EXCEPTION);
        }
        return new JsonResult();
    }
}

运行一下项目测试一下，返回json如下，说明我们自定义的业务异常捕获成功