如何重构Java中参数各异的多分支异常处理逻辑？

针对你这种因异常构造参数不一致导致if-else臃肿的问题，可以通过函数式接口封装逻辑结合HashMap或Enum来彻底消除分支判断，以下是具体实现方案：

方案1：HashMap + 函数式接口 #

通过定义函数式接口封装异常构造逻辑，将错误码与对应逻辑映射到HashMap中：

1. 定义函数式接口 #

@FunctionalInterface
private interface ExceptionHandler {
    void handle(ApiException exception, String customerNo, String code);
}

2. 初始化错误码-处理逻辑映射 #

private static final Map<String, ExceptionHandler> ERROR_HANDLERS = new HashMap<>();

static {
    ERROR_HANDLERS.put(NUMBER_ONE, (e, customerNo, code) -> {
        throw new NumberOneException(customerNo, code);
    });
    ERROR_HANDLERS.put(NUMBER_TWO, (e, customerNo, code) -> {
        throw new NumberTwoException(customerNo);
    });
    ERROR_HANDLERS.put(NUMBER_THREE, (e, customerNo, code) -> {
        throw new NumberThreeException(code);
    });
    ERROR_HANDLERS.put(NUMBER_FOUR, (e, customerNo, code) -> {
        throw new NumberFourException(customerNo, e.toError());
    });
    ERROR_HANDLERS.put(NUMBER_FIVE, (e, customerNo, code) -> {
        throw new NumberFiveException(e.toError());
    });
    // 其他错误码的处理逻辑按此格式添加
}

3. 简化handler方法 #

public void handler(ApiException exception, String customerNo, String code) {
    ExceptionHandler handler = ERROR_HANDLERS.get(exception.getCode());
    if (handler != null) {
        handler.handle(exception, customerNo, code);
    }
    // 可选：添加未匹配到错误码时的默认处理，比如抛出未知异常
    // throw new UnknownApiException(exception);
}

方案2：Enum封装（更规范集中） #

用枚举类统一管理错误码与对应的处理逻辑，适合需要强类型约束的场景：

1. 定义枚举类 #

private enum ApiError {
    NUMBER_ONE("number.one", (e, customerNo, code) -> {
        throw new NumberOneException(customerNo, code);
    }),
    NUMBER_TWO("number.two", (e, customerNo, code) -> {
        throw new NumberTwoException(customerNo);
    }),
    NUMBER_THREE("number.three", (e, customerNo, code) -> {
        throw new NumberThreeException(code);
    }),
    NUMBER_FOUR("number.four", (e, customerNo, code) -> {
        throw new NumberFourException(customerNo, e.toError());
    }),
    NUMBER_FIVE("number.five", (e, customerNo, code) -> {
        throw new NumberFiveException(e.toError());
    });

    private final String code;
    private final ExceptionHandler handler;

    ApiError(String code, ExceptionHandler handler) {
        this.code = code;
        this.handler = handler;
    }

    public static Optional<ApiError> fromCode(String code) {
        return Arrays.stream(values())
                .filter(error -> StringUtils.equals(error.code, code))
                .findFirst();
    }

    public void handle(ApiException exception, String customerNo, String code) {
        handler.handle(exception, customerNo, code);
    }

    @FunctionalInterface
    private interface ExceptionHandler {
        void handle(ApiException exception, String customerNo, String code);
    }
}

2. 简化handler方法 #

public void handler(ApiException exception, String customerNo, String code) {
    ApiError.fromCode(exception.getCode())
            .ifPresent(error -> error.handle(exception, customerNo, code));
    // 可选：默认处理逻辑
    // throw new UnknownApiException(exception);
}

方案核心原理 #

两个方案都借助函数式接口把不同异常的参数构造逻辑统一封装成相同签名的方法，不管每个异常需要哪些参数，都能在lambda表达式里自由组合传入，完美解决了你之前遇到的参数不一致问题，同时彻底消除了冗长的if-else分支。

内容的提问来源于stack exchange，提问作者Astrid