마이크로서비스의 복잡성을 해결하는 핵심 마법: 크리스 리처드슨의 8가지 패턴 완전 정복 🚀

// 1. Saga Orchestrator (중앙 지휘자) 인터페이스
public interface OrderSagaOrchestrator {
    void startOrderCreation(OrderDetails details);
    void handlePaymentSuccess(String orderId);
    void handlePaymentFailure(String orderId);
    void handleInventorySuccess(String orderId);
    void handleInventoryFailure(String orderId);
}

// 2. Order Service
@Service
public class OrderService {
    @Autowired private OrderSagaOrchestrator orchestrator;

    public String createOrder(OrderDetails details) {
        Order order = new Order(details);
        orderRepository.save(order);
        // 트랜잭션 시작을 오케스트레이터에게 지시
        orchestrator.startOrderCreation(details);
        return order.getId();
    }

    // 보상 트랜잭션 (재고 차감 실패 시 주문 취소)
    public void cancelOrder(String orderId) {
        Order order = orderRepository.findById(orderId);
        if (order != null) {
            order.setStatus(OrderStatus.CANCELED);
            orderRepository.save(order);
            // 다른 서비스에게도 보상 트랜잭션(결제 취소)을 지시해야 함 (Orchestrator 역할)
        }
    }
}

// 3. 간략화된 Saga Orchestrator 구현 (스텝 관리)
@Service
public class SimpleOrderOrchestrator implements OrderSagaOrchestrator {
    // ... 필드 (PaymentServiceProxy, InventoryServiceProxy 등)

    @Override
    public void startOrderCreation(OrderDetails details) {
        // Step 1: 결제 요청
        try {
            paymentServiceProxy.requestPayment(details.getOrderId(), details.getAmount());
        } catch (Exception e) {
            // 결제 시스템 통신 오류 시
            orderService.cancelOrder(details.getOrderId()); // 보상 트랜잭션
        }
    }
    
    @Override
    public void handlePaymentSuccess(String orderId) {
        // Step 2: 결제 성공 -> 재고 차감 요청
        inventoryServiceProxy.reserveStock(orderId);
    }

    @Override
    public void handleInventoryFailure(String orderId) {
        // Step 2 실패 시 보상 트랜잭션: Step 1 되돌리기
        paymentServiceProxy.cancelPayment(orderId);
        orderService.cancelOrder(orderId);
    }
    // ... 기타 핸들러 구현
}

// 1. 기본 이벤트 인터페이스 (불변 객체)
public interface DomainEvent {
    Instant getOccurredOn();
    String getAggregateId();
    int getVersion();
}

// 2. 특정 비즈니스 이벤트 예시
public class AccountCreatedEvent implements DomainEvent {
    private final String accountId;
    private final String ownerName;
    private final Instant occurredOn = Instant.now();
    // ... 생성자, Getter (불변성을 위해 Setter 없음)
}

public class MoneyDepositedEvent implements DomainEvent {
    private final String accountId;
    private final BigDecimal amount;
    // ...
}

// 3. 애그리거트 (Aggregate) - 상태 변화를 이벤트로 기록
public class AccountAggregate {
    private String id;
    private BigDecimal balance;
    private List<DomainEvent> changes = new ArrayList<>();

    // 상태 재구성: 이벤트 스트림을 통해 현재 상태를 만듦
    public static AccountAggregate loadFromHistory(List<DomainEvent> history) {
        AccountAggregate account = new AccountAggregate();
        history.forEach(account::apply); // 각 이벤트 적용
        account.changes.clear(); // 로드 후에는 변경 목록 초기화
        return account;
    }

    // 비즈니스 로직: 잔고 변경은 반드시 이벤트를 생성해야 함
    public void deposit(BigDecimal amount) {
        if (amount.compareTo(BigDecimal.ZERO) > 0) {
            MoneyDepositedEvent event = new MoneyDepositedEvent(this.id, amount);
            apply(event); // 내부 상태 변경
            changes.add(event); // 변경 목록에 추가
        }
    }

    // 이벤트 적용 (상태 변경 로직)
    private void apply(DomainEvent event) {
        if (event instanceof AccountCreatedEvent) {
            this.id = ((AccountCreatedEvent) event).getAccountId();
            this.balance = BigDecimal.ZERO;
        } else if (event instanceof MoneyDepositedEvent) {
            this.balance = this.balance.add(((MoneyDepositedEvent) event).getAmount());
        }
        // ... 다른 이벤트 처리
    }

    public List<DomainEvent> getUncommittedChanges() {
        return Collections.unmodifiableList(changes);
    }
}

// DTO: 고객에게 반환할 최종 조합 데이터
public class OrderDetailsDto {
    private OrderInfo orderInfo;
    private PaymentInfo paymentInfo;
    // ... (Getter, Setter)
}

// 하위 서비스와 통신할 인터페이스
public interface OrderServiceProxy {
    OrderInfo getOrderInfo(String orderId);
}

public interface PaymentServiceProxy {
    PaymentInfo getPaymentInfo(String orderId);
}

@Service
public class OrderDetailsService {

    @Autowired private OrderServiceProxy orderService;
    @Autowired private PaymentServiceProxy paymentService;
    
    // 핵심! 여러 서비스를 호출하고 데이터를 모으는 컴포지션 로직
    public OrderDetailsDto getOrderDetails(String orderId) {
        // 1. 주문 기본 정보 요청 (Order Service)
        OrderInfo orderInfo = orderService.getOrderInfo(orderId);
        
        // 2. 결제 정보 요청 (Payment Service)
        PaymentInfo paymentInfo = paymentService.getPaymentInfo(orderId);
        
        // 3. 데이터를 하나의 DTO로 조합 (Composition)
        OrderDetailsDto dto = new OrderDetailsDto();
        dto.setOrderInfo(orderInfo);
        dto.setPaymentInfo(paymentInfo);
        
        return dto;
    }
    
    // 참고: 성능 향상을 위해 병렬 호출(CompletableFuture)을 고려해야 함
    public OrderDetailsDto getOrderDetailsParallel(String orderId) {
        // 1. 주문 정보 요청을 비동기적으로 시작
        CompletableFuture<OrderInfo> orderFuture = CompletableFuture.supplyAsync(
            () -> orderService.getOrderInfo(orderId)
        );
        
        // 2. 결제 정보 요청을 비동기적으로 시작
        CompletableFuture<PaymentInfo> paymentFuture = CompletableFuture.supplyAsync(
            () -> paymentService.getPaymentInfo(orderId)
        );
        
        // 3. 두 결과가 모두 완료될 때까지 기다렸다가 조합
        return CompletableFuture.allOf(orderFuture, paymentFuture)
            .thenApply(v -> {
                OrderDetailsDto dto = new OrderDetailsDto();
                try {
                    dto.setOrderInfo(orderFuture.get());
                    dto.setPaymentInfo(paymentFuture.get());
                } catch (Exception e) {
                    throw new RuntimeException("API Composition Failed", e);
                }
                return dto;
            }).join();
    }
}

// 1. Command (쓰기 요청)
public class CreateProductCommand {
    private final String name;
    private final BigDecimal price;
    // ... Getter, 생성자
}

// 2. Command Handler (쓰기 로직 처리)
@Service
public class ProductCommandHandler {
    @Autowired private ProductRepository commandRepository; // 쓰기 전용 DB

    public String handle(CreateProductCommand command) {
        Product product = new Product(command.getName(), command.getPrice());
        commandRepository.save(product);
        // Event Sourcing을 사용한다면 여기서 ProductCreatedEvent를 발행
        return product.getId();
    }
}

// 3. Query (읽기 요청)
public class GetProductDetailQuery {
    private final String productId;
    // ... Getter, 생성자
}

// 4. Query Handler (읽기 로직 처리)
@Service
public class ProductQueryHandler {
    @Autowired private ProductViewRepository queryRepository; // 읽기 전용 DB (ex: MongoDB)

    public ProductDetailsDto handle(GetProductDetailQuery query) {
        // 비정규화된 읽기 전용 뷰에서 바로 조회
        return queryRepository.findById(query.getProductId()); 
    }
}

// 5. 컨트롤러에서 분리된 핸들러 사용
@RestController
public class ProductController {
    @Autowired private ProductCommandHandler commandHandler;
    @Autowired private ProductQueryHandler queryHandler;

    @PostMapping("/products") // 쓰기
    public String createProduct(@RequestBody CreateProductCommand command) {
        return commandHandler.handle(command);
    }

    @GetMapping("/products/{id}") // 읽기
    public ProductDetailsDto getProduct(@PathVariable String id) {
        return queryHandler.handle(new GetProductDetailQuery(id));
    }
}

// 1. build.gradle 또는 pom.xml 에 Resilience4j 의존성 추가

// 2. 외부 결제 시스템과 통신하는 프록시 서비스
@Service
public class ExternalPaymentProxy {

    private final RestTemplate restTemplate;
    
    // ... 생성자

    // @CircuitBreaker 어노테이션을 사용하여 회로 차단기 적용
    @CircuitBreaker(name = "paymentService", fallbackMethod = "fallbackPayment")
    public PaymentResult processPayment(PaymentRequest request) {
        String url = "https://external-pg.com/api/payment";
        // 외부 API 호출
        return restTemplate.postForObject(url, request, PaymentResult.class);
    }
    
    // 회로 차단기가 열리거나 호출 중 예외 발생 시 실행되는 대체 로직
    private PaymentResult fallbackPayment(PaymentRequest request, Throwable t) {
        // Log the error (t)
        System.err.println("결제 서비스 장애 발생: " + t.getMessage());
        // 결제 요청을 즉시 실패(Fail Fast) 처리하거나,
        // 메시지 큐에 넣어 나중에 재처리(Async Retry)하도록 로직 구현
        return PaymentResult.fail("External payment service is currently unavailable.");
    }
}

// 1. Outbox Event 엔티티 (DB 테이블 구조)
@Entity
@Table(name = "OUTBOX_EVENT")
public class OutboxEvent {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String aggregateId; // 어떤 엔티티에 대한 이벤트인지
    private String aggregateType; 
    private String type; // 이벤트 이름 (ex: OrderCreated)
    @Lob
    private String payload; // 이벤트 본문 (JSON 형태)
    private Instant createdOn = Instant.now();
    private boolean published = false; // Polling Publisher가 이 필드를 사용
    // ... Getter, Setter
}

// 2. 비즈니스 로직에 Outbox 저장 로직 포함 (Spring Data JPA 사용 예시)
@Service
public class OrderManagementService {
    @Autowired private OrderRepository orderRepository;
    @Autowired private OutboxEventRepository outboxRepository;

    // 하나의 DB 트랜잭션으로 묶기
    @Transactional
    public String createOrderAndPublishEvent(OrderDetails details) {
        // 1. 비즈니스 데이터 저장
        Order order = new Order(details);
        orderRepository.save(order);
        
        // 2. Outbox 테이블에 이벤트 저장 (동일 트랜잭션 내)
        OrderCreatedEvent eventPayload = new OrderCreatedEvent(order.getId(), details.getCustomerId());
        OutboxEvent outbox = new OutboxEvent();
        outbox.setAggregateId(order.getId());
        outbox.setType("OrderCreated");
        
        // Payload를 JSON으로 변환 (Jackson ObjectMapper 사용)
        outbox.setPayload(new ObjectMapper().writeValueAsString(eventPayload)); 
        outboxRepository.save(outbox);
        
        return order.getId();
    }
}