基于Springboot的全局异常拦截

自定义编码

package mybatis.utils.result;

public enum ApiCodeEnum{
    //接口正常返回数据
    SUCESS(200, "请求成功"),
    //参数缺失或者为空或者长度为0时候可用这个异常
    PARAMS_FORMAT_ERROR(300, "参数异常，请联系管理员"),
    //可用于一般后台不符合逻辑的异常
    INTERFACE_ERROR(400, "接口异常，请联系管理员"),
    //系统自带的异常，比如执行sql，空指针等异常
    FAIL(500, "系统异常，请联系管理员");

    private final int code;
    private final String msg;

    ApiCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

自定义异常

package mybatis.utils.result;

/**
 * 自定义异常
 * 采用ApiException.[异常方法]进行抛出
 **/
public class ApiException extends RuntimeException {
    //错误code码一旦确定好不可修改。
    private int exCode;
    private String exMsg;

    public ApiException(int exCode, String exMsg) {
        this.exCode = exCode;
        this.exMsg = exMsg;
    }

    //TODO 系统错误异常。这个一般系统已经自动铺获了。
    public static void fail() {
        throw new ApiException(ApiCodeEnum.FAIL.getCode(), ApiCodeEnum.FAIL.getMsg());
    }

    public static void fail(String msg) {
        throw new ApiException(ApiCodeEnum.FAIL.getCode(), msg);
    }

    //TODO 接口异常-通常指的是某段代码不符合逻辑导致的异常
    public static void interfaceFail() {
        throw new ApiException(ApiCodeEnum.INTERFACE_ERROR.getCode(), ApiCodeEnum.INTERFACE_ERROR.getMsg());
    }

    public static void interfaceFail(String msg) {
        throw new ApiException(ApiCodeEnum.INTERFACE_ERROR.getCode(), msg);
    }

    //TODO 参数异常-通常指的是参数为null或者集合长度为0
    public static void paramsFail() {
        throw new ApiException(ApiCodeEnum.PARAMS_FORMAT_ERROR.getCode(), ApiCodeEnum.PARAMS_FORMAT_ERROR.getMsg());
    }

    public static void paramsFail(String msg) {
        throw new ApiException(ApiCodeEnum.PARAMS_FORMAT_ERROR.getCode(), msg);
    }


    public int getExCode() {
        return exCode;
    }

    public void setExCode(int exCode) {
        this.exCode = exCode;
    }

    public String getExMsg() {
        return exMsg;
    }

    public void setExMsg(String exMsg) {
        this.exMsg = exMsg;
    }
}

自定义返回结果格式

package mybatis.utils.result;


import java.io.Serializable;

public class ApiResult<T> implements Serializable {
    private static final long serialVersionUID = 411731814484355577L;
    //编码，枚举中定义好，一旦确定好不可修改
    private int code;
    //信息
    private String msg;
    //返回数据
    private T data;

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

    /**
     * 请求成功，数据正常返回
     **/
    public static <T> ApiResult<T> success(T t) {
        return new ApiResult<>(ApiCodeEnum.SUCESS.getCode(), ApiCodeEnum.SUCESS.getMsg(), t);
    }

    /**
     * 请求成功，数据正常返回，并且自定义返回的msg
     **/
    public static <T> ApiResult<T> success(T t, String msg) {
        return new ApiResult<>(ApiCodeEnum.SUCESS.getCode(), msg, t);
    }


    /**
     * 系统异常，默认的msg信息
     **/
    public static <T> ApiResult<T> fail() {
        return new ApiResult<>(ApiCodeEnum.FAIL.getCode(), ApiCodeEnum.FAIL.getMsg(), null);
    }

    /**
     * 系统异常，自定义异常msg信息
     **/
    public static <T> ApiResult<T> fail(String msg) {
        return new ApiResult<>(ApiCodeEnum.FAIL.getCode(), msg, null);
    }

    /**
     * 系统异常，自定义异常msg信息和携带数据
     **/
    public static <T> ApiResult<T> fail(T t, String msg) {
        return new ApiResult<>(ApiCodeEnum.FAIL.getCode(), msg, t);
    }

    /**
     * 前台入参异常，使用默认的异常消息提示
     **/
    public static <T> ApiResult<T> paramsFail() {
        return new ApiResult<>(ApiCodeEnum.PARAMS_FORMAT_ERROR.getCode(), ApiCodeEnum.PARAMS_FORMAT_ERROR.getMsg(), null);
    }

    /**
     * 前台入参异常，自定义异常信息
     **/
    public static <T> ApiResult<T> paramsFail(String msg) {
        return new ApiResult<>(ApiCodeEnum.PARAMS_FORMAT_ERROR.getCode(), msg, null);
    }

    /**
     * 前台入参异常，自定义异常信息，并且携带数据
     **/
    public static <T> ApiResult<T> paramsFail(T t, String msg) {
        return new ApiResult<>(ApiCodeEnum.PARAMS_FORMAT_ERROR.getCode(), msg, t);
    }

    /**
     * 接口异常，使用默认的异常消息提示
     **/
    public static <T> ApiResult<T> interfaceFail() {
        return new ApiResult<>(ApiCodeEnum.INTERFACE_ERROR.getCode(), ApiCodeEnum.INTERFACE_ERROR.getMsg(), null);
    }

    /**
     * 接口异常，自定义异常信息
     **/
    public static <T> ApiResult<T> interfaceFail(String msg) {
        return new ApiResult<>(ApiCodeEnum.INTERFACE_ERROR.getCode(), msg, null);
    }

    /**
     * 接口异常，自定义异常信息，并且携带数据
     **/
    public static <T> ApiResult<T> interfaceFail(T t, String msg) {
        return new ApiResult<>(ApiCodeEnum.INTERFACE_ERROR.getCode(), msg, t);
    }


    public int getCode() {
        return code;
    }

    public void setCode(int 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;
    }
}

异常拦截

package mybatis.utils.result;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 人为手动的抛出的异常。异常类型取决于用户抛出的异常类型
     **/
    @ExceptionHandler(ApiException.class)
    public ApiResult handlerApiException(ApiException e) {
        return new ApiResult(e.getExCode(), e.getExMsg(), null);
    }

    /**
     * 系统异常，比如执行sql语句，空指针等。所有由系统产生的异常，返回固定的异常消息
     **/
    @ExceptionHandler(Exception.class)
    public ApiResult handlerException(Exception e) {
        return ApiResult.fail(e.getMessage());
    }

}

对jdk的断言方法进行了增强

package mybatis.utils.asserts;

import mybatis.utils.result.ApiCodeEnum;
import mybatis.utils.result.ApiException;

import java.util.List;
import java.util.Map;

public class AssertUtil {


    /**
     * JDK的断言增强用法
     * 发生的异常都为参数异常
     *
     * @param o 任意类型的参数
     **/
    public static void objIsNull(Object o) {
        check(o, ApiCodeEnum.PARAMS_FORMAT_ERROR.getMsg());
    }

    /**
     * @param o   任意类型的参数
     * @param msg 异常信息
     **/
    public static void objIsNull(Object o, String msg) {
        check(o, msg);
    }

    private static void check(Object o, String msg) {
        //传入对象为null抛异常
        if (null == o) {
            throwException(msg);
        }
        //string为""抛出异常
        if (o instanceof String) {
            if ("".equals(o))
                throwException(msg);
        }
        //list长度为0抛出异常
        if (o instanceof List) {
            if (((List) o).size() == 0)
                throwException(msg);
        }
        //map类型长度为0，抛出异常
        if (o instanceof Map) {
            if (((Map) o).size() == 0)
                throwException(msg);
        }
        //如果是Boolean类型，返回结果不是true抛出异常
        if (o instanceof Boolean) {
            if ((Boolean) o == false) {
                throwException(msg);
            }
        }
    }

    private static void throwException(String msg) {
        ApiException.paramsFail(msg);
    }
}

测试类

@RestController
public class TestContrller {
    @Autowired
    private TestService service;

    @GetMapping("/test")
    public ApiResult entryTest(@RequestParam Map<String, Object> map) {
        return ApiResult.success(service.entryService(map));
    }
}

@Component
public class TestService {

    public Map<String, Object> entryService(Map<String, Object> map) {
        Object name = map.get("name");
        int i = new Random().nextInt(4);
        //判断参数不可为空，为空抛出异常
        if (i == 1) {
            AssertUtil.objIsNull(name);
        }
        //发送系统异常，比如空指针、1/0，系统自动铺获
        if (i == 2) {
            System.out.println(1 / 0);
        }
        //代码执行发行逻辑不符合，属于接口异常
        if (1 == 3) {
            ApiException.interfaceFail();
        }
        //抛出参数异常
        if (i==4){
            ApiException.paramsFail();
        }
        //方法正常执行完后，返回数据即可
        return (map);
    }

}