분산 트랜잭션 — 여러 서비스에 걸친 트랜잭션은 어떻게 관리할까

주문 서비스 (MySQL)     결제 서비스 (PostgreSQL)     재고 서비스 (MongoDB)
      │                        │                         │
      └─── 각각 독립된 DB 트랜잭션 ───┘

Phase 1 (Prepare):
코디네이터 → 참여자 A: "커밋 준비 됐나?"
코디네이터 → 참여자 B: "커밋 준비 됐나?"
참여자 A → 코디네이터: "준비 완료"
참여자 B → 코디네이터: "준비 완료"

Phase 2 (Commit):
코디네이터 → 참여자 A: "커밋해라"
코디네이터 → 참여자 B: "커밋해라"

정상 흐름:
1. 주문 생성 → 2. 결제 처리 → 3. 재고 차감 → 4. 배송 요청

실패 시 보상:
3. 재고 차감 실패!
→ 2. 결제 취소 (보상)
→ 1. 주문 취소 (보상)

주문 서비스          결제 서비스          재고 서비스
    │                  │                  │
    ├─ OrderCreated ──→│                  │
    │                  ├─ PaymentDone ───→│
    │                  │                  ├─ StockReduced ──→ 완료
    │                  │                  │
    │                  │   StockFailed ←──┤
    │   PaymentRefunded ←──┤              │
    │                  │                  │
    ├─ OrderCancelled  │                  │

// 주문 서비스
@Service
public class OrderService {

    @Transactional
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        eventPublisher.publish(new OrderCreatedEvent(order.getId(), request));
    }

    @TransactionalEventListener
    public void handlePaymentFailed(PaymentFailedEvent event) {
        Order order = orderRepository.findById(event.getOrderId()).orElseThrow();
        order.cancel();  // 보상 트랜잭션
    }
}

// 결제 서비스
@Service
public class PaymentService {

    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            Payment payment = processPayment(event);
            eventPublisher.publish(new PaymentCompletedEvent(payment));
        } catch (Exception e) {
            eventPublisher.publish(new PaymentFailedEvent(event.getOrderId()));
        }
    }
}

@Service
@RequiredArgsConstructor
public class OrderSagaOrchestrator {

    private final OrderService orderService;
    private final PaymentClient paymentClient;
    private final InventoryClient inventoryClient;

    public void createOrder(OrderRequest request) {
        // Step 1: 주문 생성
        Order order = orderService.create(request);

        try {
            // Step 2: 결제
            paymentClient.processPayment(order);

            try {
                // Step 3: 재고 차감
                inventoryClient.reduceStock(order);
            } catch (Exception e) {
                // Step 3 실패 → Step 2 보상
                paymentClient.refund(order);
                orderService.cancel(order);
                throw new SagaRollbackException("재고 차감 실패", e);
            }
        } catch (PaymentException e) {
            // Step 2 실패 → Step 1 보상
            orderService.cancel(order);
            throw new SagaRollbackException("결제 실패", e);
        }
    }
}

@Transactional
public void createOrder(OrderRequest request) {
    orderRepository.save(order);       // 1. DB 저장 성공
    kafkaTemplate.send("order-event", event);  // 2. 카프카 전송 실패!
    // DB에는 저장됐지만 이벤트는 유실됨
}

@Transactional
public void createOrder(OrderRequest request) {
    Order order = orderRepository.save(new Order(request));

    // 같은 트랜잭션에서 outbox 테이블에 이벤트 저장
    outboxRepository.save(new OutboxEvent(
        "OrderCreated",
        objectMapper.writeValueAsString(new OrderCreatedEvent(order.getId()))
    ));
    // DB 트랜잭션이 커밋되면 둘 다 저장 보장
}

// 별도 프로세스: outbox 테이블을 폴링하여 메시지 브로커에 발행
@Scheduled(fixedDelay = 1000)
@Transactional
public void publishOutboxEvents() {
    List<OutboxEvent> events = outboxRepository.findByPublishedFalse();
    for (OutboxEvent event : events) {
        kafkaTemplate.send("order-events", event.getPayload());
        event.markAsPublished();
    }
}

@Service
public class PaymentEventHandler {

    @Transactional
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 멱등성 체크: 이미 처리한 이벤트인지 확인
        if (processedEventRepository.existsByEventId(event.getEventId())) {
            log.info("이미 처리된 이벤트: {}", event.getEventId());
            return;
        }

        Payment payment = processPayment(event);
        paymentRepository.save(payment);

        // 처리 완료 기록
        processedEventRepository.save(new ProcessedEvent(event.getEventId()));
    }
}