CompletableFuture通过exceptionally、handle和whenComplete方法实现异步异常处理：exceptionally仅在失败时提供备用结果，handle统一处理成功与失败并可转换结果，whenComplete则用于执行日志等副作用而不改变状态。
在Java中，
CompletableFuture
处理异步操作的异常，核心在于它提供了一系列方法来拦截、转换或响应任务执行过程中出现的错误。你可以把它想象成一个异步的
try-catch
机制，让你能够在未来的某个时间点，优雅地处理那些可能发生的意料之外。
解决方案
CompletableFuture
提供了几种主要机制来处理异常，它们各有侧重，但目标都是为了让你能够控制异步操作的失败路径。
exceptionally(Function fn)
: 这个方法就像同步代码中的
catch
块。如果前一个
CompletableFuture
异常完成，那么
fn
会被调用，接收到异常作为参数。
fn
的返回值将成为这个新的
CompletableFuture
的成功结果。如果原始
CompletableFuture
成功完成，
exceptionally
就会被跳过。它主要用于提供一个备用值或默认值，将失败的
CompletableFuture
转换为一个成功的。
handle(BiFunction fn)
: 这个方法则更像一个结合了
try-catch-finally
的操作。
fn
总是会被调用，无论前一个
CompletableFuture
是成功还是失败。如果成功，
fn
会收到结果
T
和一个
null
的
Throwable
；如果失败，它会收到一个
null
的结果和实际的
Throwable
。这让你有机会检查结果或异常，然后返回一个新的值，从而决定后续
CompletableFuture
的状态。
立即学习“Java免费学习笔记（深入）”；
whenComplete(BiConsumer 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 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
。我个人在需要为某个可能失败的操作提供一个明确的“兜底”值时，会优先考虑它。
易森网络企业版
如果您是新用户，请直接将本程序的所有文件上传在任一文件夹下，Rewrite 目录下放置了伪静态规则和筛选器，可将规则添加进IIS，即可正常使用，不用进行任何设置；(可修改图片等)默认的管理员用户名、密码和验证码都是：yeesen系统默认关闭，请上传后登陆后台点击“核心管理”里操作如下:进入“配置管理”中的&ld
0 查看详情 
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
重新抛出。这意味着，如果你在
以上就是如何在Java中使用CompletableFuture处理异常的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/743131.html
微信扫一扫 
支付宝扫一扫 
