JavaCompletableFuture异常处理全攻略

文章小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《JavaCompletableFuture异常处理技巧》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

CompletableFuture通过exceptionally、handle和whenComplete方法实现异步异常处理：exceptionally仅在失败时提供备用结果，handle统一处理成功与失败并可转换结果，whenComplete则用于执行日志等副作用而不改变状态。

在Java中，CompletableFuture 处理异步操作的异常，核心在于它提供了一系列方法来拦截、转换或响应任务执行过程中出现的错误。你可以把它想象成一个异步的 try-catch 机制，让你能够在未来的某个时间点，优雅地处理那些可能发生的意料之外。

解决方案

CompletableFuture 提供了几种主要机制来处理异常，它们各有侧重，但目标都是为了让你能够控制异步操作的失败路径。

1. exceptionally(Function fn): 这个方法就像同步代码中的 catch 块。如果前一个 CompletableFuture 异常完成，那么 fn 会被调用，接收到异常作为参数。fn 的返回值将成为这个新的 CompletableFuture 的成功结果。如果原始 CompletableFuture 成功完成，exceptionally 就会被跳过。它主要用于提供一个备用值或默认值，将失败的 CompletableFuture 转换为一个成功的。

2. handle(BiFunction fn): 这个方法则更像一个结合了 try-catch-finally 的操作。fn 总是会被调用，无论前一个 CompletableFuture 是成功还是失败。如果成功，fn 会收到结果 T 和一个 null 的 Throwable；如果失败，它会收到一个 null 的结果和实际的 Throwable。这让你有机会检查结果或异常，然后返回一个新的值，从而决定后续 CompletableFuture 的状态。

3. whenComplete(BiConsumer action): 这个方法主要用于执行副作用操作，比如日志记录或资源清理。action 也会总是被调用，接收结果和异常。但与 exceptionally 和 handle 不同的是，whenComplete 不会改变它所附加的 CompletableFuture 的结果或异常状态。如果原始 CompletableFuture 失败了，它在执行完 whenComplete 后仍然会以失败状态向下传递，除非后续有 exceptionally 或 handle 进行处理。

4. 在链中显式返回失败的 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 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 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 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 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 重新抛出。这意味着，如果你在

理论要掌握，实操不能落！以上关于《JavaCompletableFuture异常处理全攻略》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！