如何仅用handleAsync处理非异步来源的异常？

问题说明 #

Java的CompletableFuture.handleAsync只能处理CompletionStage执行链内部抛出的异常，如果在获取初始CompletableFuture的过程中就同步抛出异常（比如方法还没返回Future实例就报错），handleAsync根本不会执行，异常会直接传播给调用者。

比如这段代码：

package my.package;

import java.util.concurrent.CompletableFuture;

public class Test {

  private CompletableFuture<String> throwWithoutCompletionStage() {
    throw new RuntimeException("error");
  }

  private CompletableFuture<String> getName() {
    // 调用外部API或执行逻辑时直接抛出异常
    throwWithoutCompletionStage();
    return CompletableFuture.completedFuture("name");
  }

  public CompletableFuture<String> process() {
    return getName()
        .thenApplyAsync(result -> {
          // 处理结果
          return result;
        })
        .handleAsync((result, exception) -> {
          if (exception != null) {
            return result;
          } else {
            return null;
          }
        });
  }
}

调用process()时，getName()在执行throwWithoutCompletionStage()时直接抛出RuntimeException——此时还没返回CompletableFuture对象，后续的thenApplyAsync和handleAsync完全不会触发，异常直接抛给process()的调用者。

要覆盖所有异常场景，不得不给process()套一层try/catch，同时保留handleAsync处理Future链内的异常。这种双重捕获不仅写法怪异，还容易遗漏，很不友好。

最佳实践方案 #

方案1：用supplyAsync+thenCompose扁平化嵌套Future #

你之前尝试用supplyAsync包裹代码，但返回了嵌套的CompletableFuture<CompletableFuture<String>>，只需加上thenCompose就能扁平化Future，让返回类型回归正常，同时捕获所有异常：

public CompletableFuture<String> process() {
    return CompletableFuture.supplyAsync(this::getName)
            .thenCompose(future -> future) // 扁平化嵌套的Future
            .handleAsync((result, exception) -> {
                if (exception != null) {
                    // 异常处理逻辑，比如返回默认值
                    return "default_value";
                } else {
                    return result;
                }
            });
}

supplyAsync会把getName()的调用放到异步线程中执行，哪怕getName()同步抛异常，也会被封装到CompletableFuture里，后续的handleAsync就能正常捕获处理。thenCompose则负责把嵌套的Future展开，最终返回CompletableFuture<String>。

方案2：封装工具方法统一处理同步异常 #

更优雅的方式是写一个工具方法，把可能同步抛异常的Future生成逻辑统一包装，避免重复代码：

// 工具方法：包装可能同步抛异常的Supplier，返回CompletableFuture
private static <T> CompletableFuture<T> safeFutureSupplier(Supplier<CompletableFuture<T>> supplier) {
    try {
        return supplier.get();
    } catch (Throwable t) {
        // 同步抛异常时，返回一个已异常完成的CompletableFuture
        CompletableFuture<T> failedFuture = new CompletableFuture<>();
        failedFuture.completeExceptionally(t);
        return failedFuture;
    }
}

之后process()可以简化成：

public CompletableFuture<String> process() {
    return safeFutureSupplier(this::getName)
            .thenApplyAsync(result -> {
                // 业务处理逻辑
                return result;
            })
            .handleAsync((result, exception) -> {
                if (exception != null) {
                    return "default_value";
                } else {
                    return result;
                }
            });
}

这个工具方法会先尝试执行supplier（即getName()），如果同步抛出异常，就直接生成一个异常完成的Future，后续的Future链就能通过handleAsync正常处理这个异常，不需要额外的try/catch。

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