Java

背景

软件开发过程中，不可避免的是需要处理各种异常，所以代码中就会出现大量的 try {...} catch {...} finally {...} 代码块，不仅有大量的冗余代码，而且还影响代码的可读性。
另一个就是面对业务异常的情况，经常需要将业务异常结果组装成统一的信息返回给前端进行提示。
假如在每个接口中都去包装异常信息进行返回就会让代码变得很冗余且混乱。在实际项目开发过程中会巧用断言去简化代码。

业务异常处理示例

假设定义的标准接口响应实体为 ApiResult：

  1. @Data
  2. @Builder
  3. @NoArgsConstructor
  4. @AllArgsConstructor
  5. public class ApiResult<T> implements Serializable {
  6.     private static final long serialVersionUID = 411731814484355577L;
  7.     private int responseCode;
  8.     private String responseMsg;
  9.     private boolean isSuccess;
  10.     private T data;
  12.     public String toString() {
  13.         return "ApiResult(responseCode=" + this.getResponseCode() + ", responseMsg=" + this.getResponseMsg() + ", isSuccess=" + this.isSuccess() + ", data=" + this.getData() + ")";
  14.     }
  15. }

那么接口处理业务逻辑时代码就会变成这样，看起来非常多代码：

  1. public ApiResult cancelService(@PathVariable Long serviceOrderId){
  2.     ServiceOrder serviceOrder = serviceOrderMapper.selectByPrimaryKey(serviceOrderId);
  3.     ApiResult result = new ApiResult<>();
  4.     if (ObjectUtil.isNull(serviceOrder)) {
  5.         result.setSuccess(false);
  6.         result.setResponseCode(ErrorCodeEnum.FAIL.getCode());
  7.         result.setResponseMsg("查无此服务单");
  8.         return result;
  9.     }
  10.     if(serviceOrder.getOrderStatus().equals(cancelOrderStatus)){
  11.         result.setSuccess(false);
  12.         result.setResponseCode(ErrorCodeEnum.FAIL.getCode());
  13.         result.setResponseMsg("已取消的服务单不允许再次取消");
  14.         return result;
  15.     }
  16.     if(serviceOrder.getSortOrderId() != null){
  17.         result.setSuccess(false);
  18.         result.setResponseCode(ErrorCodeEnum.FAIL.getCode());
  19.         result.setResponseMsg("已配置物料的服务单不允许取消");
  20.         return result;
  21.     }
  22.     // ...other check
  24.     // ...do something
  25.     return result;
  26. }

然后在上面这个代码基础上，可以观察到，里面其实有非常多的重复代码，完全可以把它们装到 ApiResult 里面。
这也是看到很多开源框架的处理方式（PS：所以第一个自己写的框架也是这么处理的）

在原 ApiResult 实体中增加一些公用的处理方法

  1. public static ApiResult<String> success() {
  2.     return success("success");
  3. }
  5. public static <T> ApiResult<T> success(T data) {
  6.     return (new ApiResult()).setResponseCode(0).setResponseMsg("操作成功").setSuccess(true).setData(data);
  7. }
  9. public static ApiResult<String> fail() {
  10.     return fail(-1);
  11. }
  13. public static ApiResult<String> fail(int code) {
  14.     return fail(code, "fail");
  15. }
  17. public static <T> ApiResult<T> fail(T data) {
  18.     return fail(-1, data);
  19. }
  21. public static <T> ApiResult<T> fail(int code, T data) {
  22.     return (new ApiResult()).setResponseCode(code).setResponseMsg("操作失败").setSuccess(false).setData(data);
  23. }
  25. public static <T> ApiResult<T> success(int code, String message, T data) {
  26.     return (new ApiResult()).setResponseCode(code).setResponseMsg(message).setSuccess(true).setData(data);
  27. }
  29. public static <T> ApiResult<T> fail(int code, String message, T data) {
  30.     return (new ApiResult()).setResponseCode(code).setResponseMsg(message).setSuccess(false).setData(data);
  31. }

然后业务逻辑处理就变成这样了，看起来还不错是不是：

  1. /**
  2.   * 取消服务单(不用断言)
  3.   */
  4. public ApiResult cancelService(Long serviceOrderId){
  5.     ServiceOrder serviceOrder = serviceOrderMapper.selectByPrimaryKey(serviceOrderId);
  6.     ApiResult result = new ApiResult<>();
  7.     if (ObjectUtil.isNull(serviceOrder)) {
  8.         result = ApiResult.fail(ErrorCodeEnum.FAIL.getCode(), "查无此服务单");
  9.         return result;
  10.     }
  11.     if(serviceOrder.getOrderStatus().equals(cancelOrderStatus)){
  12.         result = ApiResult.fail(ErrorCodeEnum.FAIL.getCode(), "已取消的服务单不允许再次取消");
  13.         return result;
  14.     }
  15.     if(serviceOrder.getSortOrderId() != null){
  16.         result = ApiResult.fail(ErrorCodeEnum.FAIL.getCode(), "已配置物料的服务单不允许取消");
  17.         return result;
  18.     }
  19.     // ...other check
  21.     // ...do something
  22.     return result;
  23. }

但是可以用异常处理类+断言处理得更加简化。

增加异常处理类

  1. @Slf4j
  2. @ControllerAdvice
  3. public class GlobalExceptionHandler {
  4.     @ExceptionHandler(value = BusinessException.class)
  5.     @ResponseBody
  6.     public ResponseBean businessExceptionHandler(BusinessException e) {
  7.         log.info("business error : {}",e.getMessage(),e);
  8.         if (e.getCode() == -1) {
  9.             return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), ApiCode.SERVICE_ERROR.getMessage());
  10.         }
  11.         return ResponseBean.error(e.getCode(), e.getMessage());
  12.     }
  13. }

增加异常类 BusinessException

  1. /**
  2.   * 业务异常，异常信息会返回到前端展示给用户
  3.   *
  4.   * @date 2020/12/15 14:18
  5.   */
  6. public class BusinessException extends RuntimeException {
  7.     private static final long serialVersionUID = -5770538329754222306L;
  9.     private int code = 1;
  10.     private Level level;
  12.     public BusinessException(int code, String message, Throwable cause) {
  13.         super(message, cause);
  14.         this.code = code;
  15.     }
  17.     public BusinessException(String message) {
  18.         super(message);
  19.     }
  21.     public BusinessException(Level level, String message) {
  22.         super(message);
  23.         this.level = level;
  24.     }
  26.     public BusinessException(Throwable cause) {
  27.         super(cause);
  28.     }
  30.     public BusinessException(int code, String message) {
  31.         super(message);
  32.         this.code = code;
  33.     }
  35.     public int getCode() {
  36.         return this.code;
  37.     }
  39.     public final Level getLevel() {
  40.         return this.level;
  41.     }
  42. }

增加断言工具类 AssertUtil

  1. public class AssertUtil extends cn.com.bluemoon.common.web.exception.AssertUtil  {
  2.     public AssertUtil() {
  3.     }
  5.     /**
  6.       * 服务调用异常
  7.       * @param expression
  8.       * @param message
  9.       */
  10.     public static void isTrueServiceInvoke(boolean expression, String message) {
  11.         if (!expression) {
  12.             throw new ServiceInvokeException(message);
  13.         }
  14.     }
  16.     /**
  17.       * 抛出异常(默认错误1000)
  18.       * @param message
  19.       */
  20.     public static void businessInvalid(String message) {
  21.         throw new BusinessException(ApiCode.SERVICE_ERROR.getValue(), message);
  22.     }
  24.     /**
  25.       * 表达式为真即抛出异常(默认错误1000)
  26.       *
  27.       * @param expression
  28.       * @param message
  29.       */
  30.     public static void businessInvalid(boolean expression, String message) {
  31.         if (expression) {
  32.             throw new BusinessException(ApiCode.SERVICE_ERROR.getValue(), message);
  33.         }
  34.     }
  36.     /**
  37.       * 表达式为真即抛出异常
  38.       *
  39.       * @param expression
  40.       * @param message
  41.       */
  42.     public static void businessInvalid(boolean expression, int code, String message) {
  43.         if (expression) {
  44.             throw new BusinessException(code, message);
  45.         }
  46.     }
  47. }

最后优化的结果：

  1. /**
  2.   * 取消服务单
  3.   */
  4. public ApiResult cancelService(@PathVariable Long serviceOrderId){
  5.     ServiceOrder serviceOrder = serviceOrderMapper.selectByPrimaryKey(serviceOrderId);
  6.     AssertUtil.businessInvalid(ObjectUtil.isNull(serviceOrder),"查无此服务单");
  7.     AssertUtil.businessInvalid(serviceOrder.getOrderStatus().equals(cancelOrderStatus),"查无此服务单");
  8.     AssertUtil.businessInvalid(serviceOrder.getSortOrderId() != null,"查无此服务单");
  9.     // ...other check
  11.     // ...do something
  12.     return ApiResult.success();
  13. }

最后可以看到接口由 19 行的业务检查代码简化到了 3 行。这只是单接口的情况下，在业务多且复杂的情况下能节省更多的开发时间，把精力集中在核心业务上。

附上代码

统一异常处理类：

  1. /**
  2.   * 统一异常处理
  3.   */
  4. @Slf4j
  5. @ControllerAdvice
  6. public class GlobalExceptionHandler {
  8.     @ExceptionHandler(value = AssertException.class)
  9.     @ResponseBody
  10.     public ResponseBean bootExceptionHandler(AssertException e) {
  11.         ApiCode apiCode = ApiCode.getObjectByValue(e.getCode());
  12.         log.error("business error : {}", e.getMessage(), e);
  13.         if (e.getCode() == -1) {
  14.             return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), ApiCode.SERVICE_ERROR.getMessage());
  15.         }
  16.         return ResponseBean.error(apiCode.getValue(), e.getMessage());
  17.     }
  19.     @ExceptionHandler(value = com.alibaba.fastjson.JSONException.class)
  20.     public ResponseBean alibabaJsonExceptionHandler(com.alibaba.fastjson.JSONException e) {
  21.         ResponseBean response = new ResponseBean(false, ApiCode.PARAM_FORMAT_INCORR.getValue(), ApiCode.PARAM_FORMAT_INCORR.getMessage() + e.getMessage(), null);
  22.         log.error("1102", e);
  23.         return response;
  24.     }
  26.     @ExceptionHandler(value = JSONException.class)
  27.     @ResponseBody
  28.     public ResponseBean jsonExceptionHandler(JSONException e) {
  29.         ResponseBean response = new ResponseBean(false, ApiCode.PARAM_FORMAT_INCORR.getValue(), ApiCode.PARAM_FORMAT_INCORR.getMessage() + e.getMessage(), null);
  30.         log.error(ApiCode.PARAM_FORMAT_INCORR.getValue() + "", e);
  31.         return response;
  32.     }
  34.     @ExceptionHandler(value = JsonParseException.class)
  35.     @ResponseBody
  36.     public ResponseBean jsonParseExceptionHandler(JsonParseException e) {
  37.         ResponseBean response = new ResponseBean(false, ApiCode.PARAM_FORMAT_INCORR.getValue(), String.format(ApiCode.PARAM_FORMAT_INCORR.getMessage() + ":%s", e.getMessage()), null);
  38.         log.error(ApiCode.PARAM_FORMAT_INCORR.getValue() + "", e);
  39.         return response;
  40.     }
  42.     @ExceptionHandler(value = Exception.class)
  43.     @ResponseBody
  44.     public ResponseBean exceptionHandler(Exception e) {
  45.         ResponseBean response = new ResponseBean(false, ApiCode.SERVICE_ERROR.getValue(), ApiCode.SERVICE_ERROR.getMessage(), null);
  46.         log.error(ApiCode.SERVICE_ERROR.getValue() + "", e);
  47.         return response;
  48.     }
  50.     @ExceptionHandler(value = MethodArgumentTypeMismatchException.class)
  51.     @ResponseBody
  52.     public ResponseBean exceptionHandle(MethodArgumentTypeMismatchException e) {
  53.         ResponseBean response = new ResponseBean(false, ApiCode.PARAM_FORMAT_INCORR.getValue(), String.format(ApiCode.PARAM_FORMAT_INCORR.getMessage() + ":%s", e.getMessage()), null);
  54.         log.error(ApiCode.PARAM_FORMAT_INCORR.getValue() + "", e);
  55.         return response;
  56.     }
  58.     @ExceptionHandler(value = WebException.class)
  59.     @ResponseBody
  60.     public ResponseBean exceptionHandler(WebException e) {
  61.         ResponseBean response = new ResponseBean(e.getIsSuccess(), e.getResponseCode(), e.getResponseMsg(), null);
  62.         log.error(e.getResponseCode() + "", e);
  63.         return response;
  64.     }
  66.     @ExceptionHandler(value = IllegalArgumentException.class)
  67.     @ResponseBody
  68.     public ResponseBean exceptionHandler(IllegalArgumentException e) {
  69.         log.error("illegal request : {}", e.getMessage(), e);
  70.         return ResponseBean.error(ApiCode.PARAM_INVALID.getValue(), ApiCode.PARAM_INVALID.getMessage());
  71.     }
  73.     @ExceptionHandler(value = ServiceInvokeException.class)
  74.     @ResponseBody
  75.     public ResponseBean exceptionHandler(ServiceInvokeException e) {
  76.         log.error("serviceInvoke error request : {}", e.getMessage(), e);
  77.         return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), ApiCode.SERVICE_ERROR.getMessage());
  78.     }
  80.     @ExceptionHandler(value = BusinessException.class)
  81.     @ResponseBody
  82.     public ResponseBean businessExceptionHandler(BusinessException e) {
  83.         log.info("business error : {}",e.getMessage(),e);
  84.         if (e.getCode() == -1) {
  85.             return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), ApiCode.SERVICE_ERROR.getMessage());
  86.         }
  87.         return ResponseBean.error(e.getCode(), e.getMessage());
  88.     }
  90.     @ResponseBody
  91.     @ExceptionHandler(MethodArgumentNotValidException.class)
  92.     public ResponseBean  exceptionHandler(MethodArgumentNotValidException e) {
  93.         log.info("req params error", e);
  94.         String message = e.getBindingResult().getFieldError().getDefaultMessage();
  95.         if (StringUtils.isNotBlank(message) && !"不能为空".equals(message)) {
  96.             return ResponseBean.error(ApiCode.PARAM_INVALID.getValue(), message);
  97.         }
  98.         return ResponseBean.error(ApiCode.PARAM_INVALID.getValue(), ApiCode.PARAM_INVALID.getMessage());
  99.     }
  101.     @ExceptionHandler(value = TokenErrorException.class)
  102.     @ResponseBody
  103.     public ResponseBean tokenErrorExceptionHandler(TokenErrorException e) {
  104.         log.info("登录失效 : {}",e.getMessage(),e);
  105.         return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), "登录已失效,请重新登录！");
  106.     }
  108.     @ExceptionHandler(value = ServiceException.class)
  109.     @ResponseBody
  110.     public ResponseBean businessExceptionHandler(ServiceException e) {
  111.         log.info("service error : {}",e.getMessage(),e);
  112.         return ResponseBean.error(ApiCode.SERVICE_ERROR.getValue(), e.getMessage());
  113.     }
  114. }

异常情况枚举，仅作参考：

  1. public enum ErrorCodeEnum implements EnumBase{
  3.     FAIL(-1, "网络异常，请稍后再试"),
  5.     SUCCESS(0, "请求成功"),
  7.     MAX_UPLOAD_SIZE_ERROR(1000, "上传文件不能超过20M"),
  9.     SERVICE_BUSY_ERROR(1000, "服务器正在繁忙，请稍后再试哦~"),
  11.     REQUEST_PARAMS_FAIL(1001, "参数错误"),
  13.     USER_NOT_LOGIN(1002, "用户未登录，请重新登录"),
  15.     USER_HAS_EXIST_LOGIN(1007, "用户已经存在，请检查！"),
  17.     USER_CODE_NOT_EXIST(1008, "用户编码不存在，请检查！"),
  19.     REQUEST_PARAMS_FORMAT_ERROR(1102, "请求参数格式异常"),
  21.     PASSWORD_SAFETY_ERROE(2204, "密码不符合安全规则，请通过忘记密码重新设置8-18位数字+字母组合密码"),
  23.     TOKEN_EXPIRED(2301, "token过期"),
  25.     TOKEN_ERROR(2302, "token验证失败"),
  27.     INTERFACE_ERROR(10000, "接口服务器异常");
  29.     private final int code;
  30.     private final String msg;
  32.     ErrorCodeEnum(int code, String msg) {
  33.         this.code = code;
  34.         this.msg = msg;
  35.     }
  37.     @Override
  38.     public int getCode() {
  39.         return this.code;
  40.     }
  42.     @Override
  43.     public String getMsg() {
  44.         return this.msg;
  45.     }
  46. }