Axon Framework能否为多个Saga配置单个跟踪事件处理器？

Hey there! Let's work through this Saga tracking event processor challenge you're hitting in your large monolith with Axon Framework 3.1.2. Having a separate tracking processor for every single Saga definitely gets problematic when you've got tons of them—way too much resource overhead (threads, DB connections, etc.). Here are the key steps to fix this:

Axon 3.1.2 supports grouping Sagas (and regular event handlers) into the same tracking processor using the @ProcessingGroup annotation. This way, all Sagas in the same group share a single processor instance, cutting down on unnecessary resource usage.

Example Code #

Add the @ProcessingGroup annotation to your Saga classes, specifying the same group name for all Sagas you want to bundle:

@Saga
@ProcessingGroup("order-management-sagas")
public class OrderCreationSaga {
    // Your saga logic for order creation goes here
}

@Saga
@ProcessingGroup("order-management-sagas")
public class OrderFulfillmentSaga {
    // Your saga logic for order fulfillment goes here
}

@Saga
@ProcessingGroup("payment-sagas")
public class PaymentProcessingSaga {
    // Your saga logic for payments goes here
}

Pro tip: Group Sagas by business domain (like order management vs. payments) to keep related logic together and balance load across processors.

Once you've grouped your Sagas, tweak the processor's settings to make it efficient for your workload. If you're using Spring Boot, add these properties to your application.properties file:

# Configure the order management saga group processor
axon.eventhandling.processors.order-management-sagas.mode=tracking
axon.eventhandling.processors.order-management-sagas.thread-count=4
axon.eventhandling.processors.order-management-sagas.batch-size=50
axon.eventhandling.processors.order-management-sagas.poll-timeout=1000

# Configure the payment saga group processor
axon.eventhandling.processors.payment-sagas.mode=tracking
axon.eventhandling.processors.payment-sagas.thread-count=3
axon.eventhandling.processors.payment-sagas.batch-size=30

Let's break down these settings:

• thread-count: Number of threads the processor uses to handle events. Adjust based on your CPU cores and workload.
• batch-size: Number of events processed in a single transaction. Larger batches reduce DB roundtrips but increase transaction duration.
• poll-timeout: How long (in milliseconds) the processor waits for new events before polling again.

If you're using XML configuration instead, define the tracking processors like this:

<axon:event-processing>
    <axon:tracking-processor 
        name="order-management-sagas" 
        thread-count="4" 
        batch-size="50" 
        poll-timeout="1000"/>
    <axon:tracking-processor 
        name="payment-sagas" 
        thread-count="3" 
        batch-size="30" 
        poll-timeout="1000"/>
</axon:event-processing>

• Load Balancing: Avoid overloading a single processor group. Spread high-throughput Sagas across different groups if needed.
• Transaction Isolation: Each thread in the tracking processor runs its own transaction, so Sagas in the same group won't interfere with each other's transaction boundaries.
• Token Management: Axon uses tracking tokens to keep track of processed events. Each Saga type still gets its own token, but they're managed by the same processor instance.

This approach should drastically reduce the number of tracking processor instances in your monolith, making it more resource-efficient while keeping your Sagas running smoothly.

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