Spring项目事件驱动异步处理：需事务持久化与容错，排除Kafka

Hey there! Let's work through your problem step by step—you're looking for an event-driven framework for your Spring project that supports persistence, transactions (with full rollback if any step fails), and doesn't require ZooKeeper. I've got a few solid options tailored to your requirements:

1. Axon Framework #

This is hands down one of the best fits for your use case, especially since it’s deeply integrated with the Spring ecosystem.

• Persistence & Transaction Support: Axon has native event persistence (via its built-in event store) and first-class support for distributed transactions. Exactly what you need for that scenario where if a1, a2, or a3 fails, all related database inserts roll back.
• How Transactions Work: It integrates seamlessly with Spring’s transaction manager. Wrap your command handlers (Axon’s equivalent of Akka Actors) with @Transactional, and if any step in the chain throws an exception, the entire transaction rolls back automatically. For more complex workflows, Axon’s Saga pattern orchestrates the full process: it tracks each step’s state, and if something goes wrong, it triggers compensation actions to undo completed operations.
• No ZooKeeper Headache: Just add the axon-spring-boot-starter dependency and you’re ready to go. It’s way more intuitive for Spring developers than Akka when it comes to transaction logic.

2. Spring AMQP + RabbitMQ #

If you prefer a lighter, message-driven approach without the need for ZooKeeper, this combo is a great choice.

• Persistence: RabbitMQ supports persistent queues and messages, so your events won’t get lost if the service restarts.
• Transaction Integration: Spring AMQP works smoothly with Spring’s transaction system. Use RabbitTransactionManager alongside @Transactional to ensure database operations and message sending are atomic. For example: if you insert data into the DB then send messages to a1, a2, a3’s queues, any failure will roll back the DB insert and prevent the messages from being sent. On the consumer side, enable manual ack mode—only acknowledge the message once all database operations are successful; if it fails, the message requeues or goes to a dead-letter queue, and your transaction rolls back.

3. Spring Event + Spring Transaction (Lightweight, Single-App Scenario) #

If your workflows are contained within a single Spring app (no cross-service calls), you don’t even need a third-party framework—Spring’s built-in event system has you covered.

• Transaction Alignment: Use @TransactionalEventListener to tie event handling to your transaction state. For example, you can trigger events only after the main transaction commits, or roll back the entire transaction if any event handler throws an exception.
• Persistence: If you need to persist events, you can easily build a simple event store with Spring Data JPA to save events to your database for later replay or auditing.

A Quick Note on Akka #

Akka’s design prioritizes eventual consistency over strong transactions, which is why you struggled to implement rollback logic. While you could hack together a Saga or compensation system with Akka, it would add a ton of unnecessary complexity—far more than using one of the Spring-native options above.

内容的提问来源于stack exchange，提问作者user5448212