优雅的抛出业务异常的详细信息

分享一个在做规则中心时对异常的思考和处理方式。主要解决的问题是排查成本问题，让研发和运营同学能一眼看懂问题。

先看个例子：

public class Test {

    public static void main(String[] args) {
        String param = "1-2-3";
        System.out.println(method(param));;
    }

    private static String method(String param) {
        try {
            return method1(param.split("-")[0]);
        }catch (Exception e){
//            throw e;
            throw new RuntimeException("method异常啦~" + "param:" + param);
        }
    }

    private static String method1(String s) {
        throw new RuntimeException("method1异常啦~" + "param: " + s);
    }
}

这段代码的执行效果就是method方法的异常将method1的异常覆盖掉了，如果在method方法中throw e;又不会将method的参数带出来。我看大多数系统都是通过打错误日志来定位异常，但弊端就是错误日志打的很多，需要逐层去看(顺便吐槽一下sls需要登录的现状，我认为高效的方式应该是集团统一开放一个日志中心，各个系统去自主接入，进入日志中心选择应用就能检索)。还有一种就是将上下文一直传递，在method1中抛出详细的异常信息，这种也不符合多数场景，毕竟场景的上下文不一定相同。

那如何去管理全局异常，我想到两种方式。一种是通过ThreadLocal来记录业务执行过程&异常，一种就是抛异常将底层参数传递上去。我用的方式二。

方式比较简单，在自定义异常里增加Map字段来记录private Map<String, String> extMap; 在最底层抛的异常是这样的：

throw new RuleException(RuleErrorCodeEnum.HOT_LOAD_CLASS_PARSE_ERROR, code, e);

上层的异常处理：

} catch (RuleException e) {
      LoggerUtil.error("RuleException", e);
      throw new RuleException(e, "条件名称", conditionCache.getConditionName());
 }
.....
catch (Exception e) {
      LoggerUtil.error("xxxxxx", e);
      throw new RuleException(RuleErrorCodeEnum.UNKNOWN_ERROR, conditionCode, e);
}

RuleException的构造方法：

    public RuleException(RuleException e, String key, String value) {
        if (Objects.nonNull(e.getRuleErrorCodeEnum())) {
            this.ruleErrorCodeEnum = e.getRuleErrorCodeEnum();
        }
        if (StringUtils.isNotBlank(e.getMsg())) {
            this.msg = e.getMsg();
        }
        Map<String, String> extMsg = e.getExtMap();
        if (MapUtils.isEmpty(extMsg)) {
            extMsg = new HashMap<>();
        }
        extMsg.put(key, value);
        this.extMap = extMsg;
    }

想添加多个kv则调用setExtMsg方法:

    public void setExtMsg(String key, String value) {
        Map<String, String> extMap = this.getExtMap();
        if (MapUtils.isEmpty(extMap)) {
            extMap = new HashMap<>();
            this.extMap = extMap;
        }
        extMap.put(key, value);
    }

最外层接口的异常信息处理：

开发时保证异常大多都能被捕获到，并抛出自定义的异常

catch(Exception e){
     // log.error
     ruleResultDTO.setErrMsg(RuleException.buildErrorMsg(e, "规则接口执行异常"));
}

RuleException.buildErrorMsg方法:

    /**
     * 异常信息构建
     *
     * @param e
     * @param msg
     * @return
     */
    public static String buildErrorMsg(Exception e, String msg) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(msg);
        if (e instanceof RuleException) {
            RuleException e1 = (RuleException) e;
            if (Objects.nonNull(e1.getRuleErrorCodeEnum())) {
                stringBuilder.append(e1.getRuleErrorCodeEnum().getDesc())
                        .append(":")
                        .append(e1.getMsg());
            }
            if (MapUtils.isNotEmpty(e1.getExtMap())) {
                stringBuilder.append(JSON.toJSONString(e1.getExtMap()));
            }
            return stringBuilder.toString();
        } else {
            stringBuilder.append(e.getMessage());
        }
        return stringBuilder.toString();
    }

效果（异常信息比较简洁、聚合）： 规则接口执行异常条件执行-比较符不支持:代码中时间应该传时间戳{"规则编码":"RULE_CODE","参数名":"玩法ID","条件名称":"CONDITION_NAME","比较值":"123456789","实际值":"2020-09-09"}

如果抛出的不是自定义异常，那就只能去查日志了。

不足的地方欢迎大家点评~