StackSaga Demo (Core concept practice)

@RestController
@RequestMapping("/order")
@RequiredArgsConstructor
public class OrderController {

    (1)
    private final SagaTemplate<PlaceOrderAggregator> placeOrderAggregatorSagaTemplate;

    @PostMapping("/place")
    @ResponseStatus(HttpStatus.ACCEPTED)
    public PlaceOrderDto.ResponseBody createOrder(@RequestBody PlaceOrderDto.RequestBody requestBody) {
        (2)
        final PlaceOrderAggregator placeOrderAggregator = new PlaceOrderAggregator();
        placeOrderAggregator.setUserId(requestBody.getUserId());
        placeOrderAggregator.setItems(requestBody.getItems());
        placeOrderAggregator.setAmount(
                requestBody.getItems()
                        .stream()
                        .map(orderItem -> orderItem.getItemPrice() * orderItem.getQty())
                        .mapToDouble(Double::doubleValue)
                        .sum()
        );

        placeOrderAggregator.setHasRevertError(requestBody.getHasRevertError());
        placeOrderAggregator.getExecutions().add("INIT:" + LocalDateTime.now());
        log.debug("placeOrderAggregator:{}", placeOrderAggregator);

        (3)
        placeOrderAggregatorSagaTemplate.process(
                placeOrderAggregator,
                UserDetailExecutor.class
        );
        (4)
        return PlaceOrderDto.ResponseBody.builder()
                .orderId(placeOrderAggregator.getAggregatorTransactionId())
                .message("order has been submitted successfully")
                .build();
    }
}

import org.stacksaga.core.SagaExecutionEventName;

public enum OrderStatus implements SagaExecutionEventName {
    INITIALIZED_ORDER,
    USER_DETAILS_FETCHED,
    CANCELED_ORDER,
    MADE_PRE_AUTH,
    RELEASED_PRE_AUTH,
    UPDATED_STOCK,
    RESTORED_STOCK,
    MADE_PAYMENT,
    REFUNDED_PAYMENT
}

(1)
@SagaExecutor(executeFor = "user-service", liveCheck = false, value = "UserDetailExecutor")
@RequiredArgsConstructor
public class UserDetailExecutor implements QueryExecutor<PlaceOrderAggregator> { (2)

    (3)
    private final UserService userService;

    @Override
    public ProcessStepManager<PlaceOrderAggregator> doProcess(
            PlaceOrderAggregator currentAggregator, (4)
            ProcessStepManagerUtil<PlaceOrderAggregator> stepManager (5)
    ) throws
    RetryableExecutorException, NonRetryableExecutorException (6)
    {
        currentAggregator.getExecutions().add(this.getClass().getSimpleName()+":"+ LocalDateTime.now());
        (7)
        UserDetailDto.ResponseBody userDetails = this.userService.getUserDetails(currentAggregator.getUserId());
        (8)
        currentAggregator.setDeliveryDetails(userDetails.getDeliveryDetails());
        return stepManager.next(OrderInitializeExecutor.class, OrderStatus.USER_DETAILS_FETCHED); (9)
    }
}

@Service
@RequiredArgsConstructor
public class UserService {

    private final RestTemplate restTemplate;

    public UserDetailDto.ResponseBody getUserDetails(String userId)
            throws
            NonRetryableExecutorException,  RetryableExecutorException (1)
    {

        try {
            (2)
            UserDetailDto.ResponseBody responseBody = this.restTemplate.getForObject(
                    "http://user-service/users/{userId}",
                    UserDetailDto.ResponseBody.class,
                    userId
            );
            assert responseBody != null;
            return responseBody;
        } catch (HttpClientErrorException ex) { (3)
            // This exception is thrown for HTTP 4xx errors (Client errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.NOT_FOUND)) {
                (4)
                throw NonRetryableExecutorException
                        .buildWith(
                                new RuntimeException("User not found"),
                                ""
                        )
                        .put("reason", "User not found")
                        .build();
            } else {
                (5)
                throw NonRetryableExecutorException.buildWith(ex, "").build();
            }
        } catch (HttpServerErrorException ex) { (6)
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                (7)
                throw NonRetryableExecutorException.buildWith(ex, "").build();
            } else {
                (8)
                //502 , 503, 504, 509 etc.
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) { (9)
            // This exception is a generic RestClientException
            // Handle other types of exceptions here
            throw ex; (10)
        } catch (IllegalArgumentException illegalArgumentException) { (11)
            throw RetryableExecutorException.buildWith(illegalArgumentException).build();
        } catch (RunT) { (11)
            throw RetryableExecutorException.buildWith(illegalArgumentException).build();
        }
    }
}

(1)
@SagaExecutor(executeFor = "order-service", liveCheck = false, value = "OrderInitializeExecutor")
@RequiredArgsConstructor
public class OrderInitializeExecutor implements CommandExecutor<PlaceOrderAggregator> { (2)

    (3)
    private final OrderService orderService;
    private final ObjectMapper objectMapper;

    @Override (4)
    public ProcessStepManager<PlaceOrderAggregator> doProcess(PlaceOrderAggregator currentAggregator, ProcessStepManagerUtil<PlaceOrderAggregator> stepManager) throws RetryableExecutorException, NonRetryableExecutorException {
        try {
            currentAggregator.getExecutions().add(this.getClass().getSimpleName() + ":" + LocalDateTime.now());
            (5)
            this.orderService.initialize(
                    OrderEntity
                            .builder()
                            .orderId(currentAggregator.getAggregatorTransactionId())
                            .userId(currentAggregator.getUserId())
                            .createAt(LocalDateTime.now())
                            .isCancelled(false)
                            .items(objectMapper.writeValueAsString(currentAggregator.getItems()))
                            .build()
            );
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        (6)
        return stepManager.next(PreAuthExecutor.class, OrderStatus.INITIALIZED_ORDER);
    }

    @Override
    public SagaExecutionEventName doRevert(NonRetryableExecutorException processException, PlaceOrderAggregator finalAggregatorState, RevertHintStore revertHintStore) throws RetryableExecutorException {
        (7)
        this.orderService.cancelOrder(finalAggregatorState.getAggregatorTransactionId());
        (8)
        revertHintStore.put(
                String.valueOf(System.currentTimeMillis()),
                this.getClass().getSimpleName() + ":doRevert"
        );
        (9)
        if (finalAggregatorState.getHasRevertError()) {
            throw new RuntimeException("dummy error for revert-failed.");
        }
        (10)
        return OrderStatus.CANCELED_ORDER;
    }
}

(1)
@SagaExecutor(executeFor = "payment-service", liveCheck = false, value = "PreAuthExecutor")
@RequiredArgsConstructor
public class PreAuthExecutor implements CommandExecutor<PlaceOrderAggregator> { (2)
    private final PaymentService paymentService;

    @Override
    public ProcessStepManager<PlaceOrderAggregator> doProcess(
            PlaceOrderAggregator currentAggregator, (3)
            ProcessStepManagerUtil<PlaceOrderAggregator> stepManager
    ) throws RetryableExecutorException, NonRetryableExecutorException {
        currentAggregator.getExecutions().add(this.getClass().getSimpleName()+":"+ LocalDateTime.now());
        (4)
        final String preAuthRef = this.paymentService.makePreAuth(
                PreAuthDto
                        .RequestBody
                        .builder()
                        .userId(currentAggregator.getUserId())
                        .amount(currentAggregator.getAmount())
                        .orderId(currentAggregator.getAggregatorTransactionId())
                        .build()
        );
        (5)
        currentAggregator.setPreAuthRef(preAuthRef);
        (6)
        return stepManager.next(StockUpdateExecutor.class, OrderStatus.MADE_PRE_AUTH);
    }

    @Override
    public SagaExecutionEventName doRevert(
            NonRetryableExecutorException processException,
            PlaceOrderAggregator finalAggregatorState,
            RevertHintStore revertHintStore
    )
    throws RetryableExecutorException { (7)

        this.paymentService.releasePreAuth(
                PreAuthReleaseDto.RequestBody.builder()
                        (8)
                        .pareAuthRef(finalAggregatorState.getPreAuthRef())
                        (9)
                        .reason(processException.get("reason").orElse(""))
                        .build()
        );
        revertHintStore.put(
                String.valueOf(System.currentTimeMillis()),
                this.getClass().getSimpleName() + ":doRevert"
        );(10)

        return return OrderStatus.RELEASED_PRE_AUTH; (11)
    }
}

@Service
@RequiredArgsConstructor
public class PaymentService {

    private final RestTemplate restTemplate;

    public String makePreAuth(PreAuthDto.RequestBody requestBody)
        throws RetryableExecutorException, NonRetryableExecutorException { (1)

        try {
            (2)
            PreAuthDto.ResponseBody responseBody = this.restTemplate.postForObject(
                    "http://payment-service/pre-auth",
                    requestBody,
                    PreAuthDto.ResponseBody.class
            );
            assert responseBody != null;
            (3)
            return responseBody.getPreAuthRef();
        } catch (HttpClientErrorException ex) { (4)
            // This exception is thrown for HTTP 4xx errors (Client errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.FORBIDDEN)) {
                (5)
                throw NonRetryableExecutorException
                        .buildWith(
                                new InsufficientBalanceException("Balance not sufficient"),
                                ""
                        )
                        .build();
            } else {
                (6)
                throw NonRetryableExecutorException.buildWith(ex, "").build();
            }
        } catch (HttpServerErrorException ex) {  (7)
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                (8)
                throw NonRetryableExecutorException.buildWith(ex, "").build();
            } else {
                //502 , 503, 504, 509 etc.
                (9)
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) {  (10)
            // This exception is a generic RestClientException
            // Handle other types of exceptions here
            (11)
            throw ex;
        } catch (IllegalArgumentException illegalArgumentException) {
            throw RetryableExecutorException.buildWith(illegalArgumentException).build();
        }

    }

    public void releasePreAuth(PreAuthReleaseDto.RequestBody requestBody) throws RetryableExecutorException {
        try {
            (12)
            this.restTemplate.put(
                    "http://payment-service/pre-auth/release",
                    requestBody
            );
        } catch (HttpServerErrorException ex) {(13)
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                (14)
                throw NonRetryableExecutorException.buildWith(ex, "").build();
            } else {
                //502 , 503, 504, 509 etc.
                (15)
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) { (16)
            // This exception is thrown for HTTP 4xx errors (Client errors)
            // You can handle specific HTTP error codes here
            (17)
            throw ex;
        } catch (IllegalArgumentException illegalArgumentException) {
            throw RetryableExecutorException.buildWith(illegalArgumentException).build();
        } catch (RuntimeException restOfExceptions) { (18)
            log.error("Unhanded exception : {}", restOfExceptions.getMessage());
            log.warn("Unhanded exception was occurred and ignored while releasing pre-auth: {}", restOfExceptions.getMessage());
        }
    }
}

(1)
@SagaExecutor(executeFor = "stock-service", liveCheck = false, value = "StockUpdateExecutor")
@RequiredArgsConstructor
public class StockUpdateExecutor implements CommandExecutor<PlaceOrderAggregator> { (2)

    private final StockService stockService;

    @Override
    public ProcessStepManager<PlaceOrderAggregator> doProcess(
            PlaceOrderAggregator currentAggregator, (3)
            ProcessStepManagerUtil<PlaceOrderAggregator> stepManager
    )
    throws RetryableExecutorException, NonRetryableExecutorException {
        currentAggregator.getExecutions().add(this.getClass().getSimpleName()+":"+ LocalDateTime.now());
        (4)
        this.stockService.updateStock(
                UpdateStockDto.RequestBody
                        .builder()
                        .orderId(currentAggregator.getAggregatorTransactionId())
                        .items(currentAggregator
                                .getItems()
                                .stream()
                                .collect(
                                        Collectors.toMap(
                                                OrderItem::getItemId,
                                                OrderItem::getQty
                                        )
                                )
                        )
                        .build()
        );
        (5)
        return stepManager.next(MakePaymentExecutor.class, OrderStatus.UPDATED_STOCK);
    }

    @Override
    public String doRevert(
            NonRetryableExecutorException processException,
            PlaceOrderAggregator finalAggregatorState,
            RevertHintStore revertHintStore
    ) throws RetryableExecutorException { (6)
        (7)
        this.stockService.restoreStock(
                RestoreStockDto.RequestBody
                        .builder()
                        .reason(processException
                                .get("reason")
                                .orElse("")
                        )
                        .build()
        );
        (8)
        revertHintStore.put(
                String.valueOf(System.currentTimeMillis()),
                this.getClass().getSimpleName() + ":doRevert"
        );
        (9)
        return OrderStatus.RESTORED_STOCK;
    }
}

@Service
@RequiredArgsConstructor
public class StockService {

    private final RestTemplate restTemplate;

    public void updateStock(UpdateStockDto.RequestBody requestBody)
            throws
            RetryableExecutorException, NonRetryableExecutorException {
        try {
            (1)
            this.restTemplate.put(
                    "http://stock-service/stock",
                    requestBody
            );
        } catch (HttpServerErrorException ex) { (2)
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                throw ex;
            } else {
                //502 , 503, 504, 509 etc.
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) { (3)
            // This exception is a generic RestClientException
            // Handle other types of exceptions here
            throw ex;
        }

    }

    public void restoreStock(RestoreStockDto.RequestBody requestBody) throws RetryableExecutorException {
        try {
            (4)
            this.restTemplate.put(
                    "http://stock-service/stock/restore",
                    requestBody
            );
        } catch (HttpServerErrorException ex) { (5)
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                throw ex;
            } else {
                //502 , 503, 504, 509 etc.
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) { (6)
            // This exception is a generic RestClientException
            // Handle other types of exceptions here
            throw ex;
        }
    }
}

(1)
@SagaExecutor(executeFor = "stock-service", liveCheck = false, value = "StockUpdateExecutor")
@RequiredArgsConstructor
public class MakePaymentExecutor implements CommandExecutor<PlaceOrderAggregator> { (2)

    private final PaymentService paymentService; (3)

    @Override
    public ProcessStepManager<PlaceOrderAggregator> doProcess(
                PlaceOrderAggregator currentAggregator,
                ProcessStepManagerUtil<PlaceOrderAggregator> stepManager
    ) throws RetryableExecutorException, NonRetryableExecutorException {
        currentAggregator.getExecutions().add(this.getClass().getSimpleName()+":"+ LocalDateTime.now());
        (4)
        String paymentId = this.paymentService.makePayment(
                MakePaymentDto
                        .RequestBody
                        .builder()
                        .amount(currentAggregator.getAmount())
                        .pareAuthRef(currentAggregator.getPreAuthRef())
                        .userId(currentAggregator.getUserId())
                        .build()
        );
        (5)
        currentAggregator.setPaymentId(paymentId);
        (6)
        return stepManager.complete(OrderStatus.MADE_PAYMENT);
    }

    @Override
    public String doRevert(NonRetryableExecutorException processException, PlaceOrderAggregator finalAggregatorState, RevertHintStore revertHintStore) throws RetryableExecutorException {
        throw new UnsupportedOperationException(); (7)
    }
}

    public String makePayment(MakePaymentDto.RequestBody requestBody) throws RetryableExecutorException, NonRetryableExecutorException {
        try {
            MakePaymentDto.ResponseBody responseBody = this.restTemplate.postForObject(
                    "http://payment-service/pay",
                    requestBody,
                    MakePaymentDto.ResponseBody.class
            );
            assert responseBody != null;
            log.debug(responseBody.getMessage());
            return responseBody.getPaymentRef();
        } catch (HttpClientErrorException ex) {
            // This exception is thrown for HTTP 4xx errors (Client errors)
            // You can handle specific HTTP error codes here
            throw ex;
        } catch (HttpServerErrorException ex) {
            // This exception is thrown for HTTP 5xx errors (Server errors)
            // You can handle specific HTTP error codes here
            if (ex.getStatusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                throw ex;
            } else {
                //502 , 503, 504, 509 etc.
                throw RetryableExecutorException.buildWith(ex).build();
            }
        } catch (RestClientException ex) {
            // This exception is a generic RestClientException
            // Handle other types of exceptions here
            throw ex;
        } catch (IllegalArgumentException illegalArgumentException) {
            throw RetryableExecutorException.buildWith(illegalArgumentException).build();
        }
    }

services:
  (1)
  payment-service: http://payment-service
  stock-service: http://stock-service
  user-service: http://user-service
server:
  port: 8081
eureka:
  client:
    serviceUrl:
      (2)
      defaultZone: http://localhost:8085/eureka/
  instance:
    hostname: localhost
    (3)
    instance-id: ${spring.application.name}:${random.uuid}
spring:
  application:
    (4)
    name: order-service
  datasource:
    username: root
    password: mafei
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/stacksaga_place_order_demo_order_service?createDatabaseIfNotExist=true
  liquibase:
    (5)
    enabled: false
(6)
stacksaga:
  enable: true (7)
  component-scan: org.example.aggregator (8)
  app-release-version: 1.0.0 (9)
  connect:
    admin-urls:
      - http://localhost:4444 (10)
    admin-username: order-service-application-user (11)
    admin-password: ykLO89Irx2Q6Cf2j (11)
  datasource:
    (12)
    mysql:
      jdbc-url: jdbc:mysql://localhost:3306/order-service?createDatabaseIfNotExist=true
      username: root
      password: mafei
      driver-class-name: com.mysql.cj.jdbc.Driver

management:
  endpoint:
    env:
      enabled: true
  endpoints:
    web:
      exposure:
        include: "*"
info:
  app:
    author: mafei
    name: ${spring.application.name}
    version: ${stacksaga.app-release-version}
logging:
  pattern:
    (13)
    level: "%5p [${spring.application.name:},%X{aggregatorId:-}]"
  level:
    org:
      stacksaga: debug

$ mvn spring-boot:run