SpringBoot统一异常处理

有个完善的项目，应该尽量保证自己自己的接口出参数据接口应当尽量一致，包括出现异常也应该如此，那么我们在springboot里面如何处理呢？

1.首先定义一个接口状态的枚举类

public enum ErrorEnum {

    SUCCESS("0000","处理成功")
    ,EXCEPTION("9999","系统异常")
    ,NOMETHOD("0001","无对应方法")

    ;

    private String code;
    private String msg;

    public static ErrorEnum getErrorEnum(String code){
        for (ErrorEnum e : ErrorEnum.values()) {
            if(e.code.equals(code)){
                return e;
            }
        }
        return null;
    }

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

2.在定义一个返回数据结构，所有接口数据按照该结构进行返回

import com.liulu.springboot.Enum.ErrorEnum;

public class ResultBody<T> {

    private String code;
    private String msg;
    private T data;

    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 T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public ResultBody(ErrorEnum errorEnum){
        this.code = errorEnum.getCode();
        this.msg = errorEnum.getMsg();
    }

    public ResultBody(String code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

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

    public ResultBody(String code) {
        this.code = code;
    }

    public ResultBody() {
    }

    @Override
    public String toString() {
        return "ResultBody{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

3.自定义一个异常类，继承RuntimeException类，当异常是可以实现事物回滚

/**
 * 自定义异常类
 */
public class LiuluException  extends RuntimeException{

    private String state;
    private String data;

    public LiuluException() {}

    public LiuluException(String state ,String message){
        super(message);
        this.state = state;
    }

    public LiuluException(String message, String state, String data) {
        super(message);
        this.state = state;
        this.data = data;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

4.编写返回处理类

import com.liulu.springboot.Enum.ErrorEnum;
import com.liulu.springboot.entity.ResultBody;

public class ResultUtils {

    /**
     * 当处理成功时返回
     * @param data
     * @return
     */
    public static ResultBody getSuccessResult(String data){
        return new ResultBody(ErrorEnum.SUCCESS.getCode(),ErrorEnum.SUCCESS.getMsg(),data);
    }

    /**
     * 错误返回
     * @param errorEnum
     * @return
     */
    public static ResultBody getErrorResult(ErrorEnum errorEnum){
        if (errorEnum == null){
            errorEnum = ErrorEnum.EXCEPTION;
        }
        return new ResultBody(errorEnum.getCode(),errorEnum.getMsg());
    }

    /**
     * 自定义错误返回结果
     * @param state
     * @param msg
     * @param data
     * @return
     */
    public static ResultBody getErrorResult(String state ,String msg ,String data){
        return new ResultBody(state,msg,data);
    }
}

5.异常统一处理

import com.liulu.springboot.Enum.ErrorEnum;
import com.liulu.springboot.entity.ResultBody;
import com.liulu.springboot.exception.LiuluException;
import com.liulu.springboot.utils.ResultUtils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class ExceptionHandle {


    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public ResultBody handle(Exception e){
            e.printStackTrace();
        if(e instanceof LiuluException){
            LiuluException liuluException = (LiuluException) e;
            return ResultUtils.getErrorResult(liuluException.getState()
                    ,liuluException.getMessage(),liuluException.getData());
        }
        return ResultUtils.getErrorResult(ErrorEnum.EXCEPTION);
    }
}

这样，当我们抛出我们自定义的异常时就会统一处理成我们需要的格式。当然异常信息可以不反悔，只要告诉异常就可以了。