在开发过程中，不可避免的是需要处理各种异常，所以代码中就会出现大量的try {...} catch {...} finally {...} 代码块，不仅有大量的冗余代码，而且还影响代码的可读性。

使用统一异常处理

@ControllerAdvice 处理全局异常，可以指定不同的 ExceptionHandler 处理不同的异常。

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {


    /**
     * 业务异常
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(ServiceException.class)
    public Object businessExceptionHandler(HttpServletRequest request,HttpServletResponse response,Exception e){
        log.error("[GlobalExceptionHandler][businessExceptionHandler] exception",e);
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(JsonResultCode.FAILURE);
        jsonResult.setMessage("业务异常,请联系管理员");
        return jsonResult;
    }

    /**
     * 全局异常处理
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(Exception.class)
    public Object exceptionHandler(HttpServletRequest request,HttpServletResponse response,Exception e)
    {
        log.error("[GlobalExceptionHandler][exceptionHandler] exception",e);
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(JsonResultCode.FAILURE);
        jsonResult.setMessage("系统错误,请联系管理员");
        return jsonResult;
    }
}

使用 Assert 和Enum抛出异常

    @Test
    public void test1() {
 
        User user = userDao.selectById(userId);
        Assert.notNull(user, "用户不存在");

    }

    @Test
    public void test2() {
        User user = userDao.selectById(userId);
        if (user == null) {
            throw new userException("用户不存在.");
        }
    }

从上面的代码来看，使用 Assert 处理异常要优雅很多，但是这样做有个弊端，要定义很多自定义异常，也很麻烦。

我们可以使用 Assert 和枚举结合起来处理异常。

自定义断言

public interface BaseAssert {
    /**
     * 创建异常的接口，具体异常可由实现类来决定
     */
    BaseException newException();
    /**
     * 创建异常的接口，具体异常可由实现类来决定，支持占位符参数列表
     */
    BaseException newException(Object... args);
  
    /**
     * 断言 obj 非空。如果 obj 为空，则抛出异常
     */
    default void isNotNull(Object obj) {
        if (obj == null) {
            throw newException();
        }
    }
    /**
     * 断言 obj 非空。如果 obj 为空，则抛出异常
     * 异常信息 message 支持传递参数方式，避免字符串拼接操作
     */
    default void isNotNull(Object obj, Object... args) {
        if (obj == null) {
            throw newException(args);
        }
    }
    
    //更多类型自行定义

}

自定义基础异常

它应该属于运行时异常，并且需要有错误码（code）、错误描述（message）等属性，满足这些条件应该就可以了。

@Getter
public class BaseException extends RuntimeException {
    // 错误码
    protected String code;
    // HTTP 状态码
    protected Integer http;

    private BaseException(String code, Integer http, String msg) {
        super(msg);
        this.code = code;
        this.http = http;
    }
    private BaseException(String code, Integer http, String msg, Throwable cause) {
        super(msg, cause);
        this.code = code;
        this.http = http;
    }
    public BaseException(ExceptionResponse resp) {
        this(resp.getCode(), resp.getHttp(), resp.getMessage());
    }
    public BaseException(ExceptionResponse resp, String message) {
        this(resp.getCode(), resp.getHttp(), message);
    }
    public BaseException(ExceptionResponse resp, String message, Throwable cause) {
        this(resp.getCode(), resp.getHttp(), message, cause);
    }
}

自定义业务异常

自定义业务异常都应该继承 BaseException 。

public class BusinessException extends BaseException {
    public BusinessException(ExceptionResponse resp) {
        super(resp);
    }
    public BusinessException(ExceptionResponse resp, String message) {
        super(resp, message);
    }
}

到目前为止已经实现了断言和自定义异常，但是此时我们并没有办法直接使用断言方法。

自定义断言

public interface BusinessExceptionAssert extends ExceptionResponse, BaseAssert {
    @Override
    default BaseException newException() {
        return new BusinessException(this);
    }
    @Override
    default BaseException newException(Object... args) {
        String msg = MessageFormat.format(this.getMessage(), args);
        return new BusinessException(this, msg);
    }
}

自定义返回实体

public interface ExceptionResponse {
    /**
     * 获取返回码
     * @return 返回码
     */
    String getCode();
    /**
     * 返回 HTTP 状态码
     * @return
     */
    Integer getHttp();
    /**
     * 获取返回信息
     * @return 返回信息
     */
    String getMessage();
}

自定义枚举

public enum BusinessEnum implements BusinessExceptionAssert {

       USER_NOT_EXIST("10001", 400, "用户不存在"),

    ;

    /**
     * 返回码
     */
    private String code;
    /**
     * 状态码
     */
    private Integer http;
    /**
     * 返回消息
     */
    private String message;
  
    BusinessEnum(String code, Integer http, String message) {
        this.code = code;
        this.http = http;
        this.message = message;
    }
    @Override
    public String getCode() {
        return code;
    }
    @Override
    public String getMessage() {
        return message;
    }
    @Override
    public Integer getHttp() {
        return http;
    }
}

自定义返回实体

@Data
public class BaseResponse<T> {


    private String code;

    private String message;

    private T data;

}

全局异常处理

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 全局异常处理
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(BusinessException.class)
    public Object exceptionHandler(HttpServletRequest request, HttpServletResponse response, BusinessException e) {
        log.error("[GlobalExceptionHandler][exceptionHandler] exception",e);

        BaseResponse res = new BaseResponse();
        res.setCode(e.getCode());
        res.setMessage(e.getMessage());

        return res;
    }


}

如何使用

    @RequestMapping(value="/queryById")
    public User queryById(Integer id) {

        User user = null;

        BusinessEnum.USER_NOT_EXIST.isNotNull(user);
        return user;
    }

总结

使用断言结合枚举的方式，灵活的实现了系统异常情况的判定，既不用定义大量的异常类，让代码可读性更高，以后只需要根据特定的异常情况定义枚举常量就可以了。