CompletableFuture异步代码异常处理：如何规避冗余定义与捕获？

我经常遇到返回CompletableFuture但函数签名带有throws Exception的库方法。这类方法内的异步异常无法通过常规try-catch捕获（因为Future通常在代码离开try-catch块后才会完成），必须通过.exceptionally()处理失败。

我希望写出这样的代码：

CompletableFuture<Void> libFunction() throws Exception;

CompletableFuture<Void> caller() {
  return libFunction()
    .exceptionally(exception -> {
      // 异常处理代码
      return null;
    });
}

但Java编译器要求caller()要么在libFunction()调用外包裹try-catch块，要么在函数签名中添加throws Exception：

• 加try-catch会写出永远不会触发的冗余代码（异步异常不走这里），和.exceptionally()的逻辑重复；
• 加throws Exception则意味着整个调用链直到.join()前的所有函数都要声明该异常，但实际上这些函数并不会抛出异常——异步异常会被CompletableFuture包装为CompletionException并传递给.exceptionally()。

补充：我使用的框架会自动生成gRPC服务路由相关的签名（返回CompletionStage），由框架而非我调用.join()，无法将异常冒泡到.join()调用处。

1. 封装同步异常到CompletableFuture #

库方法签名带throws Exception，通常是因为它在返回CompletableFuture前可能有同步代码抛出异常（比如参数校验失败）。可以写一个工具方法，把同步异常捕获并包装到CompletableFuture中，统一用异步方式处理所有异常：

public static <T> CompletableFuture<T> wrapSyncException(Supplier<CompletableFuture<T>> supplier) {
    try {
        return supplier.get();
    } catch (Exception e) {
        return CompletableFuture.failedFuture(e);
    }
}

在caller()中使用该工具方法：

CompletableFuture<Void> caller() {
    return wrapSyncException(() -> libFunction())
        .exceptionally(exception -> {
            // 统一处理同步+异步异常
            log.error("处理异常", exception);
            return null;
        });
}

这样既不用给caller()加throws Exception，也不用写冗余try-catch，同步异常会被包装成失败的CompletableFuture，和异步异常一起通过.exceptionally()处理。

2. 直接捕获同步异常并包装 #

如果不想写工具方法，也可以在调用库方法时直接捕获同步异常，手动返回失败的CompletableFuture：

CompletableFuture<Void> caller() {
    CompletableFuture<Void> future;
    try {
        future = libFunction();
    } catch (Exception e) {
        future = CompletableFuture.failedFuture(e);
    }
    return future.exceptionally(exception -> {
        // 处理所有异常
        return null;
    });
}

这里的try-catch是处理同步抛出的异常，和.exceptionally()处理的异步异常分属不同场景，不存在逻辑冗余。

3. 异步执行同步逻辑（按需使用） #

如果库方法的同步逻辑可以放到异步线程中执行，也可以用CompletableFuture的异步方法包裹调用，同步异常会被自动包装到CompletableFuture中：

CompletableFuture<Void> caller() {
    return CompletableFuture.supplyAsync(() -> {
        try {
            return libFunction();
        } catch (Exception e) {
            throw new CompletionException(e);
        }
    }, executor) // 可指定线程池，或用默认线程池
    .thenCompose(Function.identity())
    .exceptionally(exception -> {
        // 处理异常
        return null;
    });
}

注意：这种方式会把库方法的同步逻辑放到异步线程执行，若原方法的同步逻辑需在当前线程执行，此方案不适用。

库方法的throws Exception是声明同步阶段可能抛出的异常，而异步阶段的异常会被CompletableFuture自动捕获包装。核心思路是：把同步异常也包装到CompletableFuture中，让所有异常都通过异步链处理，从而避免在函数签名中声明不必要的异常，也不用写冗余try-catch。

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