@Configuration
public class GatewayConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // 사용자 서비스
            .route("user-service", r -> r
                .path("/api/users/**")
                .filters(f -> f
                    .rewritePath("/api/users/(?<segment>.*)", "/users/${segment}")
                    .addRequestHeader("X-Gateway", "true"))
                .uri("lb://USER-SERVICE"))
            
            // 주문 서비스
            .route("order-service", r -> r
                .path("/api/orders/**")
                .uri("lb://ORDER-SERVICE"))
            
            // 결제 서비스
            .route("payment-service", r -> r
                .path("/api/payments/**")
                .uri("lb://PAYMENT-SERVICE"))
            
            .build();
    }
}

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    public OrderResponse createOrder(OrderRequest request) {
        // 1. 사용자 정보 확인
        String userUrl = "http://USER-SERVICE/users/" + request.getUserId();
        User user = restTemplate.getForObject(userUrl, User.class);
        
        if (user == null) {
            throw new UserNotFoundException();
        }
        
        // 2. 주문 생성
        Order order = new Order();
        order.setUserId(user.getId());
        order.setItems(request.getItems());
        orderRepository.save(order);
        
        // 3. 결제 요청
        PaymentRequest paymentRequest = new PaymentRequest();
        paymentRequest.setOrderId(order.getId());
        paymentRequest.setAmount(order.getTotalAmount());
        
        String paymentUrl = "http://PAYMENT-SERVICE/payments";
        PaymentResponse payment = restTemplate.postForObject(
            paymentUrl, 
            paymentRequest, 
            PaymentResponse.class
        );
        
        return new OrderResponse(order, payment);
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(OrderRequest request) {
        Order order = new Order();
        order.setUserId(request.getUserId());
        orderRepository.save(order);
        
        // 주문 생성 이벤트 발행
        OrderCreatedEvent event = new OrderCreatedEvent(
            order.getId(),
            order.getUserId(),
            order.getTotalAmount()
        );
        
        rabbitTemplate.convertAndSend(
            "order.exchange",
            "order.created",
            event
        );
    }
}

@Service
public class NotificationService {
    
    @RabbitListener(queues = "notification.queue")
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 주문 완료 알림 발송
        sendEmail(event.getUserId(), "주문이 완료되었습니다.");
        sendSMS(event.getUserId(), "주문 번호: " + event.getOrderId());
    }
}

@Service
public class OrderService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    @Retry(name = "paymentService", fallbackMethod = "paymentFallback")
    @TimeLimiter(name = "paymentService")
    public CompletableFuture<PaymentResponse> processPayment(PaymentRequest request) {
        return CompletableFuture.supplyAsync(() -> {
            String url = "http://PAYMENT-SERVICE/payments";
            return restTemplate.postForObject(url, request, PaymentResponse.class);
        });
    }
    
    // Fallback 메서드
    public CompletableFuture<PaymentResponse> paymentFallback(
        PaymentRequest request, 
        Exception ex
    ) {
        log.error("결제 서비스 호출 실패. Fallback 실행", ex);
        
        // 대체 로직
        PaymentResponse response = new PaymentResponse();
        response.setStatus("PENDING");
        response.setMessage("결제 처리 중입니다. 잠시 후 확인해주세요.");
        
        return CompletableFuture.completedFuture(response);
    }
}

// 1. 주문 서비스
@Service
public class OrderService {
    
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        
        // 이벤트 발행
        eventPublisher.publish(new OrderCreatedEvent(order));
    }
    
    @EventListener
    public void handlePaymentFailed(PaymentFailedEvent event) {
        // 보상 트랜잭션: 주문 취소
        Order order = orderRepository.findById(event.getOrderId());
        order.setStatus(OrderStatus.CANCELLED);
        orderRepository.save(order);
    }
}

// 2. 결제 서비스
@Service
public class PaymentService {
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            Payment payment = processPayment(event);
            eventPublisher.publish(new PaymentCompletedEvent(payment));
        } catch (Exception ex) {
            eventPublisher.publish(new PaymentFailedEvent(event.getOrderId()));
        }
    }
}

// 3. 배송 서비스
@Service
public class DeliveryService {
    
    @EventListener
    public void handlePaymentCompleted(PaymentCompletedEvent event) {
        Delivery delivery = createDelivery(event);
        eventPublisher.publish(new DeliveryStartedEvent(delivery));
    }
}

@Service
public class OrderOrchestrator {
    
    public void processOrder(OrderRequest request) {
        String sagaId = UUID.randomUUID().toString();
        
        try {
            // 1. 주문 생성
            Order order = orderService.createOrder(request);
            
            // 2. 결제 처리
            Payment payment = paymentService.processPayment(order);
            
            // 3. 재고 차감
            inventoryService.decreaseStock(order.getItems());
            
            // 4. 배송 시작
            deliveryService.startDelivery(order);
            
            // 모두 성공
            order.setStatus(OrderStatus.COMPLETED);
            
        } catch (PaymentException ex) {
            // 보상 트랜잭션
            orderService.cancelOrder(order.getId());
            throw ex;
            
        } catch (InventoryException ex) {
            // 보상 트랜잭션
            paymentService.refund(payment.getId());
            orderService.cancelOrder(order.getId());
            throw ex;
        }
    }
}

@Configuration
public class TracingConfig {
    
    @Bean
    public Tracer jaegerTracer() {
        return Configuration.fromEnv("user-service")
            .withSampler(new ConstSampler(true))
            .withReporter(new LoggingReporter())
            .getTracer();
    }
}

@Service
public class UserService {
    
    @Autowired
    private Tracer tracer;
    
    public User getUser(Long id) {
        Span span = tracer.buildSpan("getUser").start();
        
        try {
            span.setTag("userId", id);
            User user = userRepository.findById(id);
            span.log("User found: " + user.getName());
            return user;
        } catch (Exception ex) {
            span.setTag("error", true);
            span.log(ex.getMessage());
            throw ex;
        } finally {
            span.finish();
        }
    }
}

// ❌ 동기 호출의 연쇄
API Gateway → Service A (100ms)
  → Service B (100ms)
    → Service C (100ms)
      → Service D (100ms)
        
총 응답 시간: 400ms + 네트워크 지연

// ✅ 비동기 이벤트 기반
API Gateway → Service A (이벤트 발행, 즉시 응답)
  ↓ 이벤트
Service B, C, D (병렬 처리)

응답 시간: 100ms