在 Quarkus 中使用 ArC DI 实现异步 EDA：超越标准 CDI

为什么选择 ArC DI？朋友，ArC（ArC 代表 "CDI in ArC"）是 Quarkus 自己的依赖注入框架，专为轻量级和超高速而设计。它就像增强版的 CDI，但没有任何副作用。

以下是 ArC DI 成为你异步 EDA 新好伙伴的原因：

• 编译时优化：ArC 在构建时处理大部分魔法，减少运行时开销。
• 为 Quarkus 精简：它为 Quarkus 量身定制，确保无缝集成和最佳性能。
• 增强的事件处理：ArC 提供了超越标准 CDI 的事件驱动架构的专用功能。

设置你的 Quarkus 项目

首先，让我们用 ArC DI 设置一个 Quarkus 项目。如果你从头开始，可以使用 Quarkus CLI：

quarkus create app org.acme:async-eda-demo
cd async-eda-demo

ArC DI 与 Quarkus 捆绑在一起，所以你不需要添加任何额外的依赖。然而，对于我们的异步 EDA，我们需要反应式消息扩展：

./mvnw quarkus:add-extension -Dextensions="quarkus-smallrye-reactive-messaging"

使用 ArC DI 连接事件

现在，让我们动手进行一些事件连接。ArC DI 使得异步创建和处理事件变得轻而易举。这里是一个简单的例子：

import io.quarkus.arc.Arc;
import javax.enterprise.event.Event;
import javax.inject.Inject;

public class OrderService {

    @Inject
    Event orderCreatedEvent;

    public void createOrder(Order order) {
        // 处理订单
        orderCreatedEvent.fire(new OrderCreatedEvent(order));
    }
}

public class OrderEventHandler {

    public void onOrderCreated(@Observes OrderCreatedEvent event) {
        // 异步处理事件
        CompletableFuture.runAsync(() -> {
            // 执行异步操作
            System.out.println("Order created: " + event.getOrder().getId());
        });
    }
}

在这个例子中，我们使用 ArC 的事件系统将订单创建与其副作用解耦。OrderService 触发一个事件，而 OrderEventHandler 异步处理它。

在异步操作中管理上下文

异步 EDA 中最棘手的部分之一是跨不同线程管理上下文。ArC DI 通过其强大的上下文传播功能来拯救我们。让我们看看如何利用这一点：

import io.quarkus.arc.Arc;
import io.quarkus.arc.ArcContainer;

public class ContextAwareAsyncService {

    public CompletableFuture performAsyncOperation() {
        ArcContainer container = Arc.container();
        return CompletableFuture.runAsync(() -> {
            try {
                container.requestContext().activate();
                // 你的异步逻辑在这里
            } finally {
                container.requestContext().terminate();
            }
        });
    }
}

这个代码片段演示了如何在异步操作中激活和终止请求上下文，确保你的 CDI bean 及其依赖项在跨线程时正常工作。

通过 ArC 优化最小化开销

ArC DI 关注性能，并提供多种方法来最小化异步 EDA 中的开销。以下是一些保持应用程序精简高效的技巧：

1. 对于无状态服务使用 @Singleton

@Singleton
public class HighPerformanceService {
    // 无状态逻辑在这里
}

@Singleton 范围确保只创建一个 bean 实例，减少内存使用和实例化时间。

2. 对于重要的 bean 使用 @Unremovable

@Unremovable
@Singleton
public class CriticalAsyncService {
    // 这个 bean 在优化期间不会被移除
}

@Unremovable 注解防止 ArC 在构建时优化期间移除 bean，这对于动态查找或在反射密集场景中使用的 bean 至关重要。

3. 利用反应式编程模型

Quarkus 和 ArC 与反应式编程完美结合。考虑为你的异步操作使用反应式类型：

import io.smallrye.mutiny.Uni;

@Singleton
public class ReactiveOrderService {

    public Uni createOrderReactively(Order order) {
        return Uni.createFrom().item(() -> {
            // 异步订单创建逻辑
            return order;
        });
    }
}

这种方法利用了 Quarkus 的反应式核心，为你的异步 EDA 提供更好的资源利用和可扩展性。

综合示例：完整的异步 EDA 示例

让我们将所有这些概念结合成一个更全面的示例：

import io.quarkus.arc.Arc;
import io.smallrye.mutiny.Uni;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Event;
import javax.enterprise.event.Observes;
import javax.inject.Inject;

@ApplicationScoped
public class AsyncOrderSystem {

    @Inject
    Event orderEvent;

    public Uni processOrder(Order order) {
        return Uni.createFrom().item(() -> {
            // 模拟处理
            order.setStatus("PROCESSING");
            return order;
        }).onItem().invoke(processed -> {
            orderEvent.fire(new OrderEvent("PROCESSED", processed));
        });
    }

    public void onOrderEvent(@Observes OrderEvent event) {
        Uni.createFrom().item(() -> {
            System.out.println("Order " + event.getStatus() + ": " + event.getOrder().getId());
            // 执行额外的异步操作
            return event;
        }).subscribe().with(
            item -> System.out.println("Event handled successfully"),
            failure -> System.err.println("Error handling event: " + failure.getMessage())
        );
    }
}

@ApplicationScoped
public class OrderRepository {

    public Uni save(Order order) {
        return Uni.createFrom().item(() -> {
            // 模拟数据库保存
            System.out.println("Order saved: " + order.getId());
            return null;
        });
    }
}

// 主应用程序类
@QuarkusMain
public class AsyncEDAApplication {

    @Inject
    AsyncOrderSystem orderSystem;

    @Inject
    OrderRepository orderRepository;

    public static void main(String[] args) {
        Quarkus.run(AsyncEDAApplication.class, args);
    }

    @QuarkusMain
    public void run() {
        Order order = new Order("ORD-001");
        orderSystem.processOrder(order)
            .chain(processed -> orderRepository.save(processed))
            .subscribe().with(
                success -> System.out.println("Order processed and saved successfully"),
                failure -> System.err.println("Error processing order: " + failure.getMessage())
            );
    }
}

这个示例展示了：

• 使用 ArC DI 进行异步事件处理
• 使用 Mutiny 进行反应式编程
• 在异步操作中管理上下文
• 高效使用 ArC 的依赖注入功能

结论：拥抱 ArC DI 的异步未来

我们只是触及了在 Quarkus 中使用 ArC DI 实现异步 EDA 的可能性。通过利用 ArC 的专用功能，你可以创建高效、可扩展和可维护的事件驱动架构，远远超越标准 CDI 提供的功能。

记住这些关键要点：

• ArC DI 针对 Quarkus 进行了优化，为异步操作提供卓越性能。
• 正确的上下文管理对于异步 EDA 至关重要——使用 ArC 的上下文传播功能。
• 将 ArC DI 与 Quarkus 的反应式编程模型结合使用以获得最佳效果。
• 优化你的 bean 并利用 ArC 的构建时处理以最小化运行时开销。

现在去用 Quarkus 和 ArC DI 构建一些很棒的异步 EDA 吧！你的应用程序会感谢你，当用户体验到那种闪电般的响应速度时，他们也会感谢你。

"预测未来的最佳方式就是实现它。" – Alan Kay

编码愉快，愿你的事件在 Quarkus 应用程序的异步流中顺利流动！