Quarkus 中 SmallRye Reactive 的异常处理 Quarkus 中 SmallRye Reactive 的异常处理

准备好迎接一些令人费解的响应式流和巧妙的错误恢复技术。在响应式编程的世界中，异常不仅仅是恼人的中断；它们是我们事件流中的一等公民。而在 SmallRye Reactive for Quarkus 中，掌握异常处理就像在海啸上冲浪一样——刺激、具有挑战性，并且绝对至关重要。

但为什么我们要如此关注响应式编程中的异常处理呢？让我们来分析一下：

响应式流的核心是持续的数据流动。一个未处理的异常可能会让整个流程戛然而止。
在微服务架构中（Quarkus 在这方面表现出色），弹性是关键。你的服务需要比两美元的牛排更坚韧。
适当的错误处理可以决定是小问题还是全面的系统崩溃。

所以，让我们卷起袖子，深入研究 SmallRye Reactive 中的异常处理。相信我，读完这篇文章后，你将像在链锯大会上的专业杂技演员一样处理异常。

SmallRye Reactive：保持理智的基础

在我们像撒纸屑一样抛出异常之前，让我们在 SmallRye Reactive 的环境中找到方向。SmallRye Reactive 的核心是基于 Mutiny，一个让处理异步流变得轻松的响应式编程库。

SmallRye Reactive 俱乐部的第一条规则？永远为失败做好准备。让我们从基础开始：

.onFailure() 方法：你的新好朋友

把 .onFailure() 想象成你对抗异常的可靠助手。就像走钢丝时有一个安全网——你希望不需要它，但你会很高兴它在那里。这里是一个简单的例子：


Uni.createFrom().failure(new RuntimeException("Oops, I did it again!"))
    .onFailure().recoverWithItem("I'm not that innocent")
    .subscribe().with(System.out::println);

在这个小片段中，我们创建了一个 Uni（可以将其视为单个项目的响应式容器），它立即失败。但别怕！我们的 .onFailure() 方法及时出现，恢复时带有一个俏皮的布兰妮·斯皮尔斯引用。

挑剔：使用谓词的 .onFailure()

有时，你想对捕获的异常更有选择性。进入 .onFailure(predicate)。这就像在你的异常处理俱乐部有一个保镖——只有酷的异常才能进入。看看这个：


Uni.createFrom().failure(new IllegalArgumentException("Invalid argument, you dummy!"))
    .onFailure(IllegalArgumentException.class).recoverWithItem("I forgive you for being dumb")
    .onFailure().recoverWithItem("Something else went wrong")
    .subscribe().with(System.out::println);

在这里，我们专门捕获 IllegalArgumentException 并以不同于其他异常的方式处理它们。这就像为不同类型的灾难购买不同的保险——毕竟，洪水保险在地震中帮不了你。

升级：重试和指数退避

现在我们已经掌握了基础知识，让我们为我们的异常处理工具库增添一些复杂性。进入重试和指数退避——弹性响应式编程的动态二人组。

重试：如果一开始没有成功的方法

有时，处理异常的最佳方法就是再试一次。也许网络出现了小故障，或者数据库在喝咖啡。SmallRye Reactive 中的重试机制为你提供支持：


Uni.createFrom().failure(new RuntimeException("Error: Server is feeling moody"))
    .onFailure().retry().atMost(3)
    .subscribe().with(
        System.out::println,
        failure -> System.out.println("Failed after 3 attempts: " + failure)
    );

这段代码会尝试执行操作最多 3 次，然后才放弃。这就像在派对上试图引起你暗恋对象的注意——坚持不懈可能会有回报，但要知道何时放弃。

注意：不要陷入无限重试的陷阱。始终设置合理的限制，除非你希望你的应用程序一直尝试到宇宙的热寂。

指数退避：礼貌坚持的艺术

立即重试可能并不总是最佳策略。进入指数退避——礼貌地说“我稍后再试，每次等待的时间会更长”。这就像你的异常处理的“贪睡”按钮：


Uni.createFrom().failure(new RuntimeException("Error: Database is on vacation"))
    .onFailure().retry().withBackOff(Duration.ofSeconds(1), Duration.ofSeconds(10)).atMost(5)
    .subscribe().with(
        System.out::println,
        failure -> System.out.println("Failed after 5 attempts with backoff: " + failure)
    );

这段代码从 1 秒的延迟开始，然后在重试之间增加延迟，最多增加到 10 秒。这就像给那个还没有回复你的人发短信时拉开间隔——你不想显得太急切，对吧？

专业提示：始终为你的退避设置上限，以防止延迟过长。当然，除非你正在编写一个程序来在下一本《权力的游戏》书发布时唤醒你。

Null 还是不 Null：这是个问题

在响应式编程的领域中，null 值可能和异常一样麻烦。幸运的是，SmallRye Reactive 提供了优雅的方式来处理这些狡猾的 null 值。

.ifNull()：处理空值

当你期待一个值但得到 null 时，.ifNull() 是你的救星：


Uni.createFrom().item(() -> null)
    .onItem().ifNull().continueWith("Default Value")
    .subscribe().with(System.out::println);

这段代码通过提供默认值来优雅地处理 null 结果。这就像为你的备用计划准备一个备用计划——在不可预测的软件开发世界中总是个好主意。

但要小心！不要在处理异常时使用 .ifNull()。这就像试图用灭火器扑灭洪水——用错了工具，伙计。

.ifNotNull()：当你有东西可以处理时

另一方面，.ifNotNull() 让你只在有非 null 值时执行操作：


Uni.createFrom().item("Hello, Reactive World!")
    .onItem().ifNotNull().transform(String::toUpperCase)
    .subscribe().with(System.out::println);

这对于那些“只有在存在时”的场景非常完美。这就像在计划公路旅行之前检查车里是否有油——总是个好主意。

结合力量：高级异常处理技术

现在我们已经有了坚实的基础，让我们混合搭配这些技术，创造出真正强大的异常处理策略。

恢复-重试组合

有时，你想尝试从错误中恢复，如果失败了，再试一次。以下是如何链接这些操作：


Uni.createFrom().failure(new RuntimeException("Primary database unavailable"))
    .onFailure().recoverWithUni(() -> connectToBackupDatabase())
    .onFailure().retry().atMost(3)
    .subscribe().with(
        System.out::println,
        failure -> System.out.println("All attempts failed: " + failure)
    );

这段代码首先尝试通过连接到备用数据库来恢复。如果失败，它会重试整个操作最多 3 次。这就像有一个计划 B、C 和 D——你为任何事情做好了准备！

转换并征服

有时，你需要为你的错误添加更多上下文或将它们转换为更有意义的东西。transform() 方法是你的首选工具：


Uni.createFrom().failure(new RuntimeException("Database connection failed"))
    .onFailure().transform(original -> new CustomException("Failed to fetch user data", original))
    .subscribe().with(
        System.out::println,
        failure -> System.out.println("Enhanced error: " + failure)
    );

这种方法允许你为异常添加更多上下文，使调试和错误报告更加有效。这就像为你的异常添加调料——它们仍然是异常，但现在它们更有味道和信息。

常见陷阱及如何避免

即使是最有经验的开发人员在处理响应式异常时也可能会陷入陷阱。让我们看看一些常见的陷阱以及如何避免它们：

无尽重试循环的厄运

陷阱：设置重试而没有适当的限制或条件。


// 不要这样做
Uni.createFrom().failure(new RuntimeException("I will haunt you forever"))
    .onFailure().retry()
    .subscribe().with(System.out::println);

解决方案：始终设置最大重试次数或使用谓词来确定何时停止：


Uni.createFrom().failure(new RuntimeException("I'm not so scary now"))
    .onFailure().retry().atMost(5)
    .onFailure().retry().when(failure -> failure instanceof RetryableException)
    .subscribe().with(System.out::println);

空指针噩梦

陷阱：忘记在响应式流中处理潜在的 null 值。


// 如果项目为 null，这可能会爆炸
Uni.createFrom().item(() -> possiblyNullValue())
    .onItem().transform(String::toUpperCase)
    .subscribe().with(System.out::println);

解决方案：始终考虑并处理 null 值的可能性：


Uni.createFrom().item(() -> possiblyNullValue())
    .onItem().ifNotNull().transform(String::toUpperCase)
    .onItem().ifNull().continueWith("DEFAULT")
    .subscribe().with(System.out::println);

“一刀切”错误处理陷阱

陷阱：对所有类型的错误使用相同的错误处理策略。


// 这对所有错误都一视同仁
Uni.createFrom().item(() -> riskyOperation())
    .onFailure().recoverWithItem("Error occurred")
    .subscribe().with(System.out::println);

解决方案：区分不同类型的错误并相应地处理它们：


Uni.createFrom().item(() -> riskyOperation())
    .onFailure(TimeoutException.class).retry().atMost(3)
    .onFailure(IllegalArgumentException.class).recoverWithItem("Invalid input")
    .onFailure().recoverWithItem("Unexpected error")
    .subscribe().with(System.out::println);

总结：掌握异常处理！

恭喜！你刚刚提升了在 SmallRye Reactive for Quarkus 中的异常处理技能。让我们回顾一下关键点：

使用 .onFailure() 作为对抗异常的第一道防线。
使用 .retry() 实现重试机制，但始终设置合理的限制。
利用指数退避实现更复杂的重试策略。
不要忘记 null 值——使用 .ifNull() 和 .ifNotNull() 优雅地处理它们。
结合不同的技术实现强大、多层次的错误处理。
始终警惕常见陷阱，如无限重试或过于通用的错误处理。

记住，在响应式编程中，有效的异常处理不仅仅是防止崩溃——它是关于构建能够承受分布式计算混乱的弹性、自愈系统。

现在，去用 Quarkus 和 SmallRye Reactive 构建一些坚如磐石的响应式应用程序吧。愿你的流永远流动，愿你的异常得到妥善处理！

“在响应式编程的世界中，异常只是等待优雅处理的事件。” - 一位聪明的开发者（可能）

编码愉快，愿响应式力量与你同在！