In modern microservice architectures, ensuring data consistency across distributed systems can be challenging, especially when dealing with long-running transactions. The Saga Pattern provides an effective solution by breaking down a transaction into a series of smaller, autonomous steps that either succeed or execute compensating actions in case of failure. This blog post focuses on implementing Saga patterns in Spring Boot to maintain data consistency in event-driven architectures, specifically through choreography-based and orchestration-based approaches. It provides detailed code examples, technical insights, and advanced error-handling techniques.

Introduction to Saga Patterns

Distributed transactions can be difficult to manage due to the decentralized nature of microservices. In traditional monolithic applications, ACID properties ensure data consistency, but in microservices, we need a different approach. The Saga pattern solves this problem by dividing a long-running transaction into smaller sub-transactions that are managed independently. Each sub-transaction publishes events to signal success or failure, with compensating transactions available in case of failure.

There are two main Saga patterns:

  • Choreography-based Saga: Services communicate directly via events.
  • Orchestration-based Saga: A central orchestrator coordinates the transaction.

Choreography-Based Saga Pattern in Spring Boot

In this approach, services react to events by performing local transactions and emitting further events based on the outcome. It’s a decentralized pattern where each microservice knows what to do based on incoming events.

Use Case: E-Commerce Order Process

We’ll take an e-commerce platform as an example where each step involves services for inventory adjustment, payment processing, and order confirmation.

Step 1: Inventory Microservice

Java
// Event to trigger inventory adjustment
public class InventoryAdjustmentEvent {
    private String orderId;
    private String productId;
    private int quantity;
    // Getters and setters
}

// Kafka Listener for Inventory Adjustment
@Service
public class InventoryService {
    @KafkaListener(topics = "inventory-topic")
    public void adjustInventory(InventoryAdjustmentEvent event) {
        boolean success = adjustProductInventory(event.getProductId(), event.getQuantity());
        if (success) {
            PaymentInitiationEvent paymentEvent = new PaymentInitiationEvent(event.getOrderId(), event.getProductId(), event.getQuantity());
            kafkaTemplate.send("payment-topic", paymentEvent);
        } else {
            OrderCancellationEvent cancelEvent = new OrderCancellationEvent(event.getOrderId());
            kafkaTemplate.send("order-cancel-topic", cancelEvent);
        }
    }
}

Step 2: Payment Microservice

Java
// Payment Event
public class PaymentInitiationEvent {
    private String orderId;
    private double amount;
    // Getters and setters
}

// Payment Processing
@Service
public class PaymentService {
    @KafkaListener(topics = "payment-topic")
    public void processPayment(PaymentInitiationEvent event) {
        boolean success = processPayment(event.getOrderId(), event.getAmount());
        if (success) {
            OrderConfirmationEvent confirmationEvent = new OrderConfirmationEvent(event.getOrderId());
            kafkaTemplate.send("order-confirm-topic", confirmationEvent);
        } else {
            PaymentFailureEvent failureEvent = new PaymentFailureEvent(event.getOrderId());
            kafkaTemplate.send("payment-failure-topic", failureEvent);
        }
    }
}

Compensating Transactions in Choreography

If one of the steps in the transaction fails, compensating actions are performed to revert previous actions.

Java
// Order Cancellation Listener
@Service
public class OrderCancellationService {
    @KafkaListener(topics = "order-cancel-topic")
    public void cancelOrder(OrderCancellationEvent event) {
        updateOrderStatus(event.getOrderId(), "CANCELLED");
        rollbackInventoryAdjustment(event.getOrderId());
    }
}

Orchestration-Based Saga Pattern in Spring Boot

In an orchestration-based Saga, a central Saga orchestrator coordinates the entire flow. The orchestrator sends commands to individual services and handles responses to ensure that either the whole transaction is successful or compensating actions are triggered.

Orchestrator Service

Java
@Service
public class SagaOrchestrator {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

    public void startOrderSaga(OrderSagaRequest request) {
        InventoryAdjustmentEvent event = new InventoryAdjustmentEvent(request.getOrderId(), request.getProductId(), request.getQuantity());
        kafkaTemplate.send("inventory-topic", event);
    }

    @KafkaListener(topics = "inventory-response-topic")
    public void handleInventoryResponse(InventoryResponseEvent event) {
        if (event.isSuccess()) {
            PaymentInitiationEvent paymentEvent = new PaymentInitiationEvent(event.getOrderId(), event.getAmount());
            kafkaTemplate.send("payment-topic", paymentEvent);
        } else {
            OrderCancellationEvent cancelEvent = new OrderCancellationEvent(event.getOrderId());
            kafkaTemplate.send("order-cancel-topic", cancelEvent);
        }
    }
}

Inventory and Payment Services

The inventory and payment services now respond to commands from the orchestrator, ensuring centralized control.

Java
// Inventory Adjustment
@Service
public class InventoryService {
    @KafkaListener(topics = "inventory-topic")
    public void adjustInventory(InventoryAdjustmentEvent event) {
        boolean success = adjustProductInventory(event.getProductId(), event.getQuantity());
        InventoryResponseEvent responseEvent = new InventoryResponseEvent(event.getOrderId(), success);
        kafkaTemplate.send("inventory-response-topic", responseEvent);
    }
}
Java
// Payment Processing
@Service
public class PaymentService {
    @KafkaListener(topics = "payment-topic")
    public void processPayment(PaymentInitiationEvent event) {
        boolean success = processPayment(event.getOrderId(), event.getAmount());
        PaymentResponseEvent responseEvent = new PaymentResponseEvent(event.getOrderId(), success);
        kafkaTemplate.send("payment-response-topic", responseEvent);
    }
}

Error Handling and Failure Scenarios

Handling errors and failures is crucial in any distributed system. In both Choreography and Orchestration patterns, you need strategies for managing failures. Let’s dive into some common approaches:

1. Timeouts and Retries

In distributed transactions, failures can occur due to network issues, service downtime, or timeouts. Implementing retry mechanisms and timeouts is essential to handle transient failures.

Java
// Retry Mechanism in Payment Service
@Service
public class PaymentService {
    private static final int MAX_RETRIES = 3;

    @Retryable(maxAttempts = MAX_RETRIES, backoff = @Backoff(delay = 2000))
    public void processPaymentWithRetry(PaymentInitiationEvent event) {
        boolean success = processPayment(event.getOrderId(), event.getAmount());
        if (!success) throw new RuntimeException("Payment failed, retrying...");
    }
}

2. Idempotency

Idempotency ensures that compensating actions can be applied multiple times without adverse effects. For instance, cancelling an order multiple times should have the same result as cancelling it once.

Java
// Idempotent Cancellation Logic
public void cancelOrder(String orderId) {
    Order order = orderRepository.findById(orderId);
    if (!"CANCELLED".equals(order.getStatus())) {
        order.setStatus("CANCELLED");
        orderRepository.save(order);
        // Additional compensation logic...
    }
}

3. Compensating Transactions

If a service fails after partially completing its work, compensating transactions should be executed to rollback any changes. This is handled automatically by the Saga orchestrator or by emitting failure events in the choreography pattern.

Java
// Compensating Transaction in Inventory Service
public void rollbackInventoryAdjustment(String orderId) {
    InventoryRecord record = inventoryRepository.findByOrderId(orderId);
    if (record != null) {
        record.adjustQuantity(-record.getReservedQuantity());
        inventoryRepository.save(record);
    }
}

The Saga pattern is a robust solution for managing data consistency in distributed, event-driven architectures. In this post, we explored how to implement both choreography-based and orchestration-based Sagas in Spring Boot using Kafka. By applying the right error-handling strategies like retries, idempotency, and compensating transactions, you can ensure that your system maintains consistency and reliability even in complex distributed environments.

With these patterns and examples, you now have the foundational knowledge to manage distributed transactions across microservices efficiently.

Categorized in:

KafkaResilience PatternsSagasSpring Boot