Orchestration-Based Saga Architecture and Spring Boot Microservices Implementation Guide

The image illustrates an orchestration-based saga pattern for handling distributed transactions across two microservices: Order Service and Customer Service. This approach uses a central orchestrator (the saga) to coordinate the interactions between services and ensure consistency. Here’s an end-to-end explanation of the flow:

1. Order Creation Request

A client sends an HTTP POST /orders request to the Order Controller in the Order Service.
The Order Controller is responsible for receiving the request and delegating it to the Order Service.

2. Order Creation in the Saga

The Order Service invokes the create() method in the Create Order Saga.
The Create Order Saga is the orchestrator responsible for coordinating the steps involved in completing the transaction.

3. Order Aggregate Creation

The Create Order Saga initiates the creation of the Order aggregate in the Order Service.
The Order aggregate represents the state and business logic of the order.

4. Reserve Credit Command

After creating the Order aggregate, the Create Order Saga sends a Reserve Credit Command to the Customer Service through a message broker.
The message broker decouples the communication between the services, ensuring reliable message delivery.
- The Customer Service Command Channel in the broker is responsible for routing the Reserve Credit Command to the Customer Service.

5. Handling the Reserve Credit Command

In the Customer Service, a Command Handler listens for incoming commands from the message broker.
When the Reserve Credit Command is received, the handler invokes the reserve() method in the Customer Service.

6. Customer Aggregate Update

The reserve() method interacts with the Customer aggregate to reserve the required credit for the order.
The Customer aggregate ensures that the customer has sufficient credit to reserve.

7. Reserve Credit Response

Once the credit reservation is completed (or fails), the Customer Service sends a Reserve Credit Response back to the Create Order Saga via the Create Order Saga Reply Channel in the message broker.

8. Order Approval

If the Reserve Credit Response indicates success, the Create Order Saga invokes the approve() method on the Order aggregate in the Order Service.
The Order aggregate updates its state to reflect that the order has been approved and is ready for further processing.

Key Components and Interactions

Order Service:
- Handles the initial order creation request and coordinates the saga.
- Maintains the Order aggregate.
Customer Service:
- Responsible for reserving credit for the customer.
- Maintains the Customer aggregate.
Create Order Saga:
- Acts as the orchestrator for the entire transaction.
- Coordinates the steps and handles responses to ensure eventual consistency.
Message Broker:
- Facilitates asynchronous communication between services.
- Decouples the services, enabling scalability and fault tolerance.

Error Handling (Implied)

If any step fails (e.g., credit reservation fails), the Create Order Saga can trigger compensating actions (e.g., cancel the order or roll back changes).
The orchestration ensures that the system maintains consistency even in the event of partial failures.

This design ensures:

Scalability: Services communicate asynchronously, allowing independent scaling.
Resilience: Decoupling through the message broker makes the system tolerant to failures in individual services.
Consistency: The saga orchestrates the distributed transaction to maintain data integrity.

Below is an example of implementing the orchestration-based saga with two Spring Boot microservices (Order Service and Customer Service) based on the architecture provided. The communication is event-driven using Kafka.

1. Setup

Dependencies

Add the following dependencies to both services' pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

2. Kafka Configuration

In both services, configure Kafka:

`application.yml`:

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: order-group
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

3. Order Service Implementation

Entities

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String status; // PENDING, APPROVED, REJECTED
    private Double amount;

    // Getters and setters
}

Repository

public interface OrderRepository extends JpaRepository<Order, Long> {}

Service

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public Order createOrder(Double amount) {
        Order order = new Order();
        order.setAmount(amount);
        order.setStatus("PENDING");
        orderRepository.save(order);

        // Send Reserve Credit Command
        kafkaTemplate.send("reserve-credit", String.valueOf(order.getId()));

        return order;
    }

    public void approveOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.setStatus("APPROVED");
        orderRepository.save(order);
    }

    public void rejectOrder(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.setStatus("REJECTED");
        orderRepository.save(order);
    }
}

Controller

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;

    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestParam Double amount) {
        Order order = orderService.createOrder(amount);
        return ResponseEntity.ok(order);
    }
}

Kafka Listener

@Service
public class OrderEventListener {
    @Autowired
    private OrderService orderService;

    @KafkaListener(topics = "reserve-credit-response", groupId = "order-group")
    public void handleReserveCreditResponse(String message) {
        String[] data = message.split(":");
        Long orderId = Long.parseLong(data[0]);
        String status = data[1];

        if ("APPROVED".equals(status)) {
            orderService.approveOrder(orderId);
        } else {
            orderService.rejectOrder(orderId);
        }
    }
}

4. Customer Service Implementation

Entities

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Double creditLimit;
    private Double creditReserved;

    // Getters and setters
}

Repository

public interface CustomerRepository extends JpaRepository<Customer, Long> {}

Service

@Service
public class CustomerService {
    @Autowired
    private CustomerRepository customerRepository;

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void reserveCredit(Long orderId, Double amount) {
        Customer customer = customerRepository.findAll().get(0); // Simplified for example
        String response;

        if (customer.getCreditLimit() - customer.getCreditReserved() >= amount) {
            customer.setCreditReserved(customer.getCreditReserved() + amount);
            customerRepository.save(customer);
            response = orderId + ":APPROVED";
        } else {
            response = orderId + ":REJECTED";
        }

        // Send response
        kafkaTemplate.send("reserve-credit-response", response);
    }
}

Kafka Listener

@Service
public class CustomerEventListener {
    @Autowired
    private CustomerService customerService;

    @KafkaListener(topics = "reserve-credit", groupId = "customer-group")
    public void handleReserveCredit(String orderId) {
        // Simplified logic with a hardcoded amount for example
        customerService.reserveCredit(Long.parseLong(orderId), 100.0);
    }
}

5. Testing

Start Kafka on localhost:9092.
Run the Order Service and Customer Service.
Use POST /orders with an amount to create an order.
Observe the event-driven communication:
- Order Service sends a "Reserve Credit" command to Kafka.
- Customer Service processes the command and responds with success/failure.
- Order Service updates the order's status based on the response.

Search This Blog

DevSyncra