MSA 핵심 패턴 — Circuit Breaker, API Gateway, Service Discovery, Saga

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Service
@RequiredArgsConstructor
public class OrderService {

    private final RestClient restClient;

    @CircuitBreaker(name = "orderService", fallbackMethod = "getOrderFallback")
    public OrderResponse getOrder(Long orderId) {
        return restClient.get()
                .uri("http://order-service/api/orders/{id}", orderId)
                .retrieve()
                .body(OrderResponse.class);
    }

    // 서킷이 OPEN이거나 호출 실패 시 실행되는 fallback
    private OrderResponse getOrderFallback(Long orderId, Throwable throwable) {
        log.warn("Circuit Breaker fallback 실행: orderId={}, error={}",
                orderId, throwable.getMessage());

        // 캐시된 데이터 반환, 기본값 반환, 또는 대체 서비스 호출
        return OrderResponse.builder()
                .orderId(orderId)
                .status("UNKNOWN")
                .message("주문 서비스가 일시적으로 불가합니다. 잠시 후 다시 시도해주세요.")
                .build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
@CircuitBreaker(name = "orderService", fallbackMethod = "getOrderFallback")
@Retry(name = "orderService")
@TimeLimiter(name = "orderService")
public CompletableFuture<OrderResponse> getOrderAsync(Long orderId) {
    return CompletableFuture.supplyAsync(() ->
            restClient.get()
                    .uri("http://order-service/api/orders/{id}", orderId)
                    .retrieve()
                    .body(OrderResponse.class)
    );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Component
@RequiredArgsConstructor
public class CircuitBreakerMonitor {

    private final CircuitBreakerRegistry registry;

    @EventListener(ApplicationReadyEvent.class)
    public void registerEventListeners() {
        CircuitBreaker cb = registry.circuitBreaker("orderService");

        cb.getEventPublisher()
                .onStateTransition(event ->
                        log.warn("Circuit Breaker 상태 변경: {} → {}",
                                event.getStateTransition().getFromState(),
                                event.getStateTransition().getToState()))
                .onFailureRateExceeded(event ->
                        log.error("실패율 임계치 초과: {}%",
                                event.getFailureRate()));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 커스텀 필터: JWT 인증
@Component
public class JwtAuthFilter implements GatewayFilterFactory<JwtAuthFilter.Config> {

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            String token = exchange.getRequest()
                    .getHeaders().getFirst("Authorization");

            if (token == null || !token.startsWith("Bearer ")) {
                exchange.getResponse()
                        .setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }

            // JWT 검증 로직
            String jwt = token.substring(7);
            Claims claims = validateToken(jwt);

            // 검증된 사용자 정보를 헤더에 추가하여 하위 서비스로 전달
            ServerHttpRequest modifiedRequest = exchange.getRequest()
                    .mutate()
                    .header("X-User-Id", claims.getSubject())
                    .header("X-User-Role", claims.get("role", String.class))
                    .build();

            return chain.filter(
                    exchange.mutate().request(modifiedRequest).build());
        };
    }

    public static class Config {}
}

1
2
3
4
5
6
7
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Order Service — 주문 생성 후 이벤트 발행
@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;

    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        Order order = Order.create(request);
        order.setStatus(OrderStatus.PENDING);
        orderRepository.save(order);

        kafkaTemplate.send("order-events", order.getId(),
                new OrderCreatedEvent(order.getId(), order.getAmount(),
                        order.getItems()));
        return order;
    }

    // Payment 실패 시 보상 트랜잭션
    @KafkaListener(topics = "payment-events", groupId = "order-service")
    public void handlePaymentEvent(PaymentEvent event) {
        if (event instanceof PaymentFailedEvent failed) {
            Order order = orderRepository.findById(failed.getOrderId())
                    .orElseThrow();
            order.setStatus(OrderStatus.CANCELLED);
            order.setCancelReason("결제 실패: " + failed.getReason());
            orderRepository.save(order);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Payment Service — 결제 처리 후 이벤트 발행
@Service
@RequiredArgsConstructor
public class PaymentService {

    @KafkaListener(topics = "order-events", groupId = "payment-service")
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            Payment payment = processPayment(event.getOrderId(),
                    event.getAmount());

            kafkaTemplate.send("payment-events", event.getOrderId(),
                    new PaymentCompletedEvent(event.getOrderId(),
                            payment.getId()));
        } catch (PaymentException e) {
            kafkaTemplate.send("payment-events", event.getOrderId(),
                    new PaymentFailedEvent(event.getOrderId(),
                            e.getMessage()));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@Service
@RequiredArgsConstructor
public class OrderSagaOrchestrator {

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

    public OrderResult executeOrderSaga(CreateOrderRequest request) {
        Order order = null;
        String paymentId = null;

        try {
            // Step 1: 주문 생성
            order = orderService.createOrder(request);

            // Step 2: 결제 처리
            paymentId = paymentClient.processPayment(
                    order.getId(), order.getAmount());

            // Step 3: 재고 차감
            inventoryClient.reserveStock(order.getId(), order.getItems());

            // 모든 단계 성공
            order.setStatus(OrderStatus.CONFIRMED);
            orderService.save(order);

            return OrderResult.success(order);

        } catch (PaymentException e) {
            // 결제 실패 → 주문 취소
            if (order != null) {
                orderService.cancelOrder(order.getId(),
                        "결제 실패: " + e.getMessage());
            }
            return OrderResult.failure("결제 실패");

        } catch (InventoryException e) {
            // 재고 부족 → 결제 취소 → 주문 취소 (역순 보상)
            if (paymentId != null) {
                paymentClient.refundPayment(paymentId);
            }
            if (order != null) {
                orderService.cancelOrder(order.getId(),
                        "재고 부족: " + e.getMessage());
            }
            return OrderResult.failure("재고 부족");
        }
    }
}