CompletableFuture通过exceptionally、handle和whenComplete方法实现异步异常处理：exceptionally仅在失败时提供备用结果，handle统一处理成功与失败并可转换结果，whenComplete则用于执行日志等副作用而不改变状态。
在Java中，
CompletableFuture处理异步操作的异常，核心在于它提供了一系列方法来拦截、转换或响应任务执行过程中出现的错误。你可以把它想象成一个异步的
try-catch机制，让你能够在未来的某个时间点，优雅地处理那些可能发生的意料之外。
解决方案
CompletableFuture提供了几种主要机制来处理异常，它们各有侧重，但目标都是为了让你能够控制异步操作的失败路径。
exceptionally(Function<Throwable, T> fn)
: 这个方法就像同步代码中的catch
块。如果前一个CompletableFuture
异常完成，那么fn
会被调用，接收到异常作为参数。fn
的返回值将成为这个新的CompletableFuture
的成功结果。如果原始CompletableFuture
成功完成，exceptionally
就会被跳过。它主要用于提供一个备用值或默认值，将失败的CompletableFuture
转换为一个成功的。-
handle(BiFunction<T, Throwable, R> fn)
: 这个方法则更像一个结合了try-catch-finally
的操作。fn
总是会被调用，无论前一个CompletableFuture
是成功还是失败。如果成功，fn
会收到结果T
和一个null
的Throwable
；如果失败，它会收到一个null
的结果和实际的Throwable
。这让你有机会检查结果或异常，然后返回一个新的值，从而决定后续CompletableFuture
的状态。立即学习“Java免费学习笔记（深入）”；
whenComplete(BiConsumer<T, Throwable> action)
: 这个方法主要用于执行副作用操作，比如日志记录或资源清理。action
也会总是被调用，接收结果和异常。但与exceptionally
和handle
不同的是，whenComplete
不会改变它所附加的CompletableFuture
的结果或异常状态。如果原始CompletableFuture
失败了，它在执行完whenComplete
后仍然会以失败状态向下传递，除非后续有exceptionally
或handle
进行处理。在链中显式返回失败的
CompletableFuture
: 有时，你可能在thenApply
或thenCompose
这样的转换方法中检测到错误，并希望立即终止后续链条并抛出异常。这时，你可以返回CompletableFuture.failedFuture(new Exception("..."))。
以下是一些代码示例，展示了这些方法的实际应用：
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
public class CompletableFutureExceptionHandling {
public static void main(String[] args) throws InterruptedException {
System.out.println("--- 示例 1: 使用 exceptionally() ---");
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
if (ThreadLocalRandom.current().nextBoolean()) {
throw new RuntimeException("任务 1 出错了！"); // 模拟随机失败
}
return "任务 1 的结果";
}).exceptionally(ex -> {
System.err.println("exceptionally 捕获到异常 (任务 1): " + ex.getMessage());
return "任务 1 的备用结果"; // 提供一个备用值
});
future1.thenAccept(result -> System.out.println("任务 1 最终结果: " + result));
System.out.println("\n--- 示例 2: 使用 handle() ---");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
if (ThreadLocalRandom.current().nextBoolean()) {
throw new IllegalStateException("任务 2 因状态问题失败！"); // 模拟随机失败
}
return "任务 2 的结果";
}).handle((result, ex) -> {
if (ex != null) {
System.err.println("handle 捕获到异常 (任务 2): " + ex.getMessage());
return "任务 2 的处理后备用结果"; // 将失败转换为成功，并提供信息
}
return result + " (成功处理)"; // 成功时也进行转换
});
future2.thenAccept(result -> System.out.println("任务 2 最终结果: " + result));
System.out.println("\n--- 示例 3: 使用 whenComplete() 进行副作用操作 ---");
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
if (ThreadLocalRandom.current().nextBoolean()) {
throw new ArithmeticException("任务 3 发生算术错误！"); // 模拟随机失败
}
return "任务 3 的结果";
}).whenComplete((result, ex) -> {
if (ex != null) {
System.err.println("副作用: 任务 3 失败，异常信息: " + ex.getMessage());
} else {
System.out.println("副作用: 任务 3 成功完成，结果: " + result);
}
}).exceptionally(ex -> { // whenComplete 不改变状态，如果需要处理失败，仍需 exceptionally 或 handle
System.err.println("whenComplete 后捕获异常 (任务 3): " + ex.getMessage());
return "任务 3 的最终备用结果";
});
future3.thenAccept(result -> System.out.println("任务 3 最终结果: " + result));
System.out.println("\n--- 示例 4: 链式调用中传播失败 ---");
CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(() -> {
System.out.println("开始执行任务 4");
if (true) { // 强制失败，用于演示
throw new RuntimeException("任务 4 强制失败");
}
return 10;
}).thenApply(data -> { // 如果上一步失败，这一步不会执行
System.out.println("任务 4 正在处理数据: " + data);
return data * 2;
}).exceptionally(ex -> {
System.err.println("任务 4 链中捕获异常: " + ex.getMessage());
return -1; // 提供一个错误值
});
future4.thenAccept(val -> System.out.println("任务 4 最终值: " + val));
// 等待所有异步任务完成，以便观察输出
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}exceptionally()
、handle()
和 whenComplete()
之间有什么关键区别？
这三者是
CompletableFuture异常处理的核心，但它们的设计目的和行为模式有着显著差异，理解这些区别对于写出健壮的异步代码至关重要。
exceptionally()专注于异常恢复。它只在之前的
CompletableFuture遇到异常时才会被触发。如果上游任务成功完成，
exceptionally()会被完全跳过。它的主要作用是提供一个“Plan B”，当主路径失败时，能返回一个预设的、默认的或经过转换的成功值，从而将一个失败的
Future变为一个成功的
Future。我个人在需要为某个可能失败的操作提供一个明确的“兜底”值时，会优先考虑它。
handle()则更加灵活和通用。无论上游
CompletableFuture是成功还是失败，
handle()都会执行。它会同时接收到结果（如果成功）和异常（如果失败），其中一个会是
null。这种设计允许你在这里统一处理成功和失败两种情况，你可以根据传入的参数来决定返回什么。你可以选择继续传播成功，将异常转换为一个成功的结果，甚至重新抛出一个新的异常。在我看来，
handle()是一个强大的“决策点”，当你需要对异步操作的最终状态进行统一的判断和转换时，它非常有用。
whenComplete()的目的在于副作用操作。它也总是会执行，无论成功或失败，同样接收结果和异常。但与前两者最根本的区别在于，
whenComplete()不会改变它所依附的
CompletableFuture的状态。这意味着，如果上游
Future失败了，即使
whenComplete()执行了它的逻辑（比如打印日志），这个
Future仍然会以失败状态向下传递。我通常用
whenComplete()来做一些“事后清理”或者“状态报告”的工作，比如记录日志、更新监控指标，而不需要影响整个异步链的执行结果。
简而言之：
exceptionally()
：只处理失败，并提供一个成功的回退值。handle()
：处理成功和失败，并转换结果。whenComplete()
：处理成功和失败，但不改变结果，主要用于副作用。
如何避免在 CompletableFuture
链中丢失异常信息？
在
CompletableFuture的世界里，异常的“丢失”是一个常见且令人头疼的问题，它往往导致调试变得异常困难。这种情况通常不是指异常真的消失了，而是指它被悄无声息地处理了，或者被转换成了一个不那么有用的形式，导致你无法追溯其根源。
要避免这种情况，我认为有几个关键点：
首先，务必记录原始异常。无论你使用
exceptionally()还是
handle()来捕获异常，都应该在处理逻辑中将捕获到的
Throwable完整地记录下来，包括堆栈信息。仅仅返回一个默认值而不记录异常，就等于把问题“扫到地毯下面”，将来出了问题，你根本不知道发生了什么。例如，
exceptionally(ex -> { log.error("Async task failed", ex); return "default"; }) 远比 exceptionally(ex -> "default")要负责得多。
其次，谨慎选择异常处理策略。如果你在
exceptionally()或
handle()中返回
null或者一个不具代表性的值，而下游代码又依赖于非
null或特定类型的值，那么你只是把一个异步异常转换成了一个更隐蔽的
NullPointerException或类型转换异常。这比直接看到原始异常更糟糕。如果无法提供有意义的恢复值，考虑重新抛出一个更具业务含义的异常，或者使用
CompletableFuture.failedFuture(new MyBusinessException("...")) 来明确地传播失败。
再者，理解 join()
和 get()
的行为。当你在
CompletableFuture上调用
join()或
get()（通常在异步链的末端或需要阻塞等待结果时），如果
CompletableFuture以异常方式完成，这两个方法会将其内部的
CompletionException或
ExecutionException重新抛出。这意味着，如果你在
