Spring boot异常统一处理

自定义异常类

@Getter
public class MyException extends RuntimeException{
 
    private ErrorCodeEnum errorCodeEnum;
 
    public MyException(ErrorCodeEnum errorCodeEnum) {
        this.errorCodeEnum = errorCodeEnum;
    }
}

自定义异常处理

这里是利用了AOP，建立一个切片去捕捉异常，分类处理

我们可以更改value来捕获我们自己定义的异常（这个只能是由我们自己手动抛出的）

因此为了更方便简洁，我们可以使用枚举类型和断言

@Slf4j
@ControllerAdvice
public class BasicExceptionHandler {
 
    /**
     * description: errorHandler 处理算数运算异常<br>
     * @version: 1.0
     * @date: 2022/12/27 0027 下午 4:44
     * @author: William
     * @param exception 异常
     * @return com.example.springbootdemo.common.response.Result
     */
    @ResponseBody
    @ExceptionHandler(value = ArithmeticException.class)
    public Result errorHandler(ArithmeticException exception) {
        return Result.build(500, "算数运算异常");
    }
 
    /**
     * description: errorHandler 处理自定义异常<br>
     * @version: 1.0
     * @date: 2022/12/27 0027 下午 3:32
     * @author: William
     * @param exception  自定义异常
     * @return java.util.Map<java.lang.String,java.lang.Object>
     */
    @ResponseBody
    @ExceptionHandler(value = MyException.class)
    public Result errorHandler(MyException exception) {
        return Result.error(exception.getErrorCodeEnum());
    }
 
 
    /**
     * description: errorHandler 处理全局异常<br>
     * @version: 1.0
     * @date: 2022/12/27 0027 下午 3:37
     * @author: William
     * @param exception   异常
     * @return java.util.Map<java.lang.String,java.lang.Object>
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public Result errorHandler(Exception exception) {
        return Result.build(500, exception.getMessage());
    }
 
}

枚举类型

@Getter
@AllArgsConstructor
public enum ErrorCodeEnum{

    OK("0000","工作正常"),
    /**
     * 一级错误码
     * --用户端错误
     * --系统错误
     * --第三方错误
     */

    USER_ERROR("A0001","用户端错误"),
    SYSTEM_ERROR("B0001","系统执行错误"),
    THIRD_SERVICE_ERROR("C0001","第三方出错"),

    /**
     * 二级错误码
     * --用户注册错误
     * --用户请求参数错误
     * --响应超时
     */
    USER_REGISTER_ERROR("A0002","注册出错"),
    WRONG_PASSWORD_ERROR("A0005","密码错误"),
    USER_TESTIFYCODE_ERROR("A0006","验证码错误"),
    USER_ALREADY_EXISTS("A0007","用户已存在"),
    USER_REQ_PARAM_ERROR("A0003","请求参数出错"),
    USER_NOTEXISTS("A0004","用户不存在"),
    SYSTEM_TIMEOUT_ERROR("B0002","系统响应超时");
    /**
     * 三级错误码
     * 待补充
     */
    //    错误码
    private String code;
    //    错误信息
    private String msg;
}

 于是，我们可以利用枚举类型来规范返回内容格式一致性

形如
    @ExceptionHandler(BindException.class)
    public RestResp<Void> ParamError(BindException e){
        log.error(e.getMessage(),e);
        return RestResp.fail(ErrorCodeEnum.USER_REQ_PARAM_ERROR);
    }
而非
    @ExceptionHandler(BindException.class)
    public RestResp<Void> ParamError(BindException e){
        log.error(e.getMessage(),e);
        return RestResp.fail("xxxx","xxxx);
    }

断言

使用断言代替传统if、esle

public class AssertTests {

	//if else的用法
    @Test
    public void test1() {
        Object o = null;
        if (o == null) {
            throw new IllegalArgumentException("用户不存在.");
        }
    }

	//断言的用法：更为简洁
    @Test
    public void test2() {
        // 另一种写法
        Object o = null;
        Assert.notNull(o, "用户不存在.");
    }
}

自定义断言，抛出我们自己创建的异常类型

@Slf4j
public abstract class MyAssert {

    /**
     * 断言对象不为空
     * 如果对象obj为空，则抛出异常
     * @param obj 待判断对象
     */
    public static void notNull(Object obj, ResponseEnum responseEnum) {
        if (obj == null) {
            log.info("obj is null...............");
            throw new MyException(responseEnum);
        }
    }
    
	public static void notNull(Object obj, String msg) {
        if (obj == null) {
            log.info("obj is null...............");
            throw new MyException(msg);
        }
    }
	 /**
     * 断言对象为空
     * 如果对象obj不为空，则抛出异常
     *
     * @param object
     * @param responseEnum
     */
    public static void isNull(Object object, ResponseEnum responseEnum) {
        if (object != null) {
            log.info("obj is not null......");
            throw new MyException(responseEnum);
        }
    }

    /**
     * 断言表达式为真
     * 如果不为真，则抛出异常
     *
     * @param expression 是否成功
     */
    public static void isTrue(boolean expression, ResponseEnum responseEnum) {
        if (!expression) {
            log.info("fail...............");
            throw new MyException(responseEnum);
        }
    }

    /**
     * 断言两个对象不相等
     * 如果相等，则抛出异常
     *
     * @param m1
     * @param m2
     * @param responseEnum
     */
    public static void notEquals(Object m1, Object m2, ResponseEnum responseEnum) {
        if (m1.equals(m2)) {
            log.info("equals...............");
            throw new MyException(responseEnum);
        }
    }

    /**
     * 断言两个对象相等
     * 如果不相等，则抛出异常
     *
     * @param m1
     * @param m2
     * @param responseEnum
     */
    public static void equals(Object m1, Object m2, ResponseEnum responseEnum) {
        if (!m1.equals(m2)) {
            log.info("not equals...............");
            throw new MyException(responseEnum);
        }
    }

    /**
     * 断言参数不为空
     * 如果为空，则抛出异常
     *
     * @param s
     * @param responseEnum
     */
    public static void notEmpty(String s, ResponseEnum responseEnum) {
        if (StringUtils.isEmpty(s)) {
            log.info("is empty...............");
            throw new MyException(responseEnum);
        }
    }
}