Merge pull request #153 from rnqhstmd/round6

[volume-6] 외부 시스템 장애 및 지연 대응

Author: rnqhstmd

apps/commerce-api/build.gradle.kts

@@ -21,4 +21,11 @@ dependencies {
     testImplementation(testFixtures(project(":modules:redis")))
 
     testImplementation("net.datafaker:datafaker:2.0.2")
+
+    // Resilience4j
+    implementation("io.github.resilience4j:resilience4j-spring-boot3")
+    implementation("org.springframework.boot:spring-boot-starter-aop")
+
+    // OpenFeign
+    implementation("org.springframework.cloud:spring-cloud-starter-openfeign")
 }

apps/commerce-api/src/main/java/com/loopers/CommerceApiApplication.java

@@ -4,8 +4,15 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
 import java.util.TimeZone;
 
+@EnableFeignClients(basePackages = "com.loopers.infrastructure.pg")
+@EnableScheduling
+@EnableAsync
 @ConfigurationPropertiesScan
 @SpringBootApplication
 public class CommerceApiApplication {

apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java

@@ -4,15 +4,14 @@
 import com.loopers.domain.coupon.CouponService;
 import com.loopers.domain.order.Order;
 import com.loopers.domain.order.OrderService;
-import com.loopers.domain.point.PointService;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
-import org.springframework.orm.ObjectOptimisticLockingFailureException;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -21,66 +20,118 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+@Slf4j
 @Component
 @RequiredArgsConstructor
-@Transactional(readOnly = true)
 public class OrderFacade {
 
-    private final OrderService orderService;
     private final UserService userService;
     private final ProductService productService;
-    private final PointService pointService;
     private final CouponService couponService;
+    private final OrderService orderService;
 
     @Transactional
-    public OrderInfo placeOrder(OrderPlaceCommand command) {
-        User user = userService.getUserByUserId(command.userId());
+    public OrderInfo createOrder(OrderPlaceCommand command) {
+        log.info("주문 생성 시작: userBusinessId={}, items={}",
+                command.userId(), command.items().size());
 
-        List<Long> productIds = command.items().stream()
-                .map(OrderPlaceCommand.OrderItemCommand::productId)
-                .sorted()
-                .toList();
+        // 1. 사용자 조회
+        User user = userService.getUserByUserId(command.userId());
 
+        // 2. 상품 조회 (데드락 방지를 위한 정렬 + 비관적 락)
+        List<Long> productIds = extractAndSortProductIds(command.items());
         List<Product> products = productService.getProductsByIdsWithPessimisticLock(productIds);
-        Map<Long, Product> productMap = products.stream()
-                .collect(Collectors.toMap(Product::getId, Function.identity()));
+        Map<Long, Product> productMap = toProductMap(products);
 
+        // 3. 재고 검증 및 차감 (도메인 로직은 Product가 처리)
         validateAndDecreaseStock(command.items(), productMap);
 
-        Order order = Order.create(user);
+        // 4. 주문 생성 (도메인 서비스 위임)
+        List<OrderService.OrderItemRequest> itemRequests = command.items().stream()
+                .map(item -> OrderService.OrderItemRequest.of(item.productId(), item.quantity()))
+                .toList();
+        Order order = orderService.createOrderWithItems(user, itemRequests, productMap);
 
-        for (OrderPlaceCommand.OrderItemCommand item : command.items()) {
-            Product product = productMap.get(item.productId());
-            order.addOrderItem(product, item.quantity());
-        }
+        // 5. 쿠폰 적용 (선택)
+        Long discountAmount = applyCouponIfExists(command.couponId(), user, order);
+
+        // 6. 주문 저장
+        Order savedOrder = orderService.save(order);
+
+        log.info("주문 생성 완료: orderId={}, totalAmount={}, discountAmount={}",
+                savedOrder.getId(), savedOrder.getTotalAmountValue(), discountAmount);
 
-        Long totalAmount = order.getTotalAmountValue();
-        Long discountAmount = 0L;
-        Long couponId = command.couponId();
+        return OrderInfo.from(savedOrder, discountAmount);
+    }
 
-        if (couponId != null) {
-            Coupon coupon = couponService.getCouponWithOptimisticLock(couponId);
-            couponService.validateCouponUsable(coupon, user);
+    @Transactional
+    public void cancelOrder(Long orderId, Long couponId) {
+        log.info("주문 취소 시작: orderId={}", orderId);
 
-            discountAmount = coupon.calculateDiscount(totalAmount);
-            coupon.use();
-            couponService.save(coupon);
+        Order order = orderService.getOrderById(orderId);
+
+        // 1. 재고 복구
+        List<Long> productIds = order.getOrderItems().stream()
+                .map(item -> item.getProductId())
+                .sorted()
+                .toList();
+        List<Product> products = productService.getProductsByIdsWithPessimisticLock(productIds);
+        Map<Long, Product> productMap = toProductMap(products);
+
+        orderService.restoreStock(order, productMap);
+
+        // 2. 쿠폰 복구
+        Long couponIdToRestore = couponId != null ? couponId : order.getCouponId();
+        if (couponIdToRestore != null) {
+            restoreCoupon(couponIdToRestore);
         }
-        long finalAmount = totalAmount - discountAmount;
-        pointService.usePointWithLock(user.getUserIdValue(), finalAmount);
 
+        // 3. 주문 취소 상태 변경
+        order.markAsCancelled();
+        orderService.save(order);
+
+        log.info("주문 취소 완료: orderId={}", orderId);
+    }
+
+    @Transactional
+    public void completeOrder(Long orderId) {
+        log.info("주문 완료 처리: orderId={}", orderId);
+
+        Order order = orderService.getOrderById(orderId);
         order.completePayment();
-        Order savedOrder = orderService.save(order);
+        orderService.save(order);
+
+        log.info("주문 완료: orderId={}", orderId);
+    }
+
+    @Transactional(readOnly = true)
+    public List<OrderInfo> getMyOrders(String userId) {
+        User user = userService.getUserByUserId(userId);
+        List<Order> orders = orderService.getOrdersByUser(user);
+
+        return orders.stream()
+                .map(order -> OrderInfo.from(order, 0L))
+                .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public OrderInfo getOrderDetail(Long orderId, String userId) {
+        User user = userService.getUserByUserId(userId);
+        Order order = orderService.getOrderByIdAndUser(orderId, user);
 
-        return OrderInfo.from(savedOrder);
+        return OrderInfo.from(order, 0L);
     }
 
-    private void validateAndDecreaseStock(List<OrderPlaceCommand.OrderItemCommand> items, Map<Long, Product> productMap) {
+    private void validateAndDecreaseStock(
+            List<OrderPlaceCommand.OrderItemCommand> items,
+            Map<Long, Product> productMap
+    ) {
         for (OrderPlaceCommand.OrderItemCommand item : items) {
             Product product = productMap.get(item.productId());
 
             if (product == null) {
-                throw new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다.");
+                throw new CoreException(ErrorType.NOT_FOUND,
+                        "상품을 찾을 수 없습니다: " + item.productId());
             }
 
             if (!product.isStockAvailable(item.quantity())) {
@@ -92,19 +143,55 @@ private void validateAndDecreaseStock(List<OrderPlaceCommand.OrderItemCommand> i
         }
     }
 
-    public List<OrderInfo> getMyOrders(String userId) {
-        User user = userService.getUserByUserId(userId);
-        List<Order> orders = orderService.getOrdersByUser(user);
+    /**
+     * 쿠폰 적용
+     */
+    private Long applyCouponIfExists(Long couponId, User user, Order order) {
+        if (couponId == null) {
+            return 0L;
+        }
 
-        return orders.stream()
-                .map(OrderInfo::from)
-                .toList();
+        Coupon coupon = couponService.getCouponWithOptimisticLock(couponId);
+        couponService.validateCouponUsable(coupon, user);
+
+        Long discountAmount = coupon.calculateDiscount(order.getTotalAmountValue());
+        coupon.use();
+        couponService.save(coupon);
+
+        order.applyCoupon(couponId);
+
+        log.info("쿠폰 적용 완료: couponId={}, discountAmount={}", couponId, discountAmount);
+
+        return discountAmount;
     }
 
-    public OrderInfo getOrderDetail(Long orderId, String userId) {
-        User user = userService.getUserByUserId(userId);
-        Order order = orderService.getOrderByIdAndUser(orderId, user);
+    /**
+     * 쿠폰 복구
+     */
+    private void restoreCoupon(Long couponId) {
+        Coupon coupon = couponService.getCouponWithOptimisticLock(couponId);
+        coupon.restore();
+        couponService.save(coupon);
+        log.debug("쿠폰 복구: couponId={}", couponId);
+    }
 
-        return OrderInfo.from(order);
+    /**
+     * 상품 ID 추출 및 정렬
+     */
+    private List<Long> extractAndSortProductIds(
+            List<OrderPlaceCommand.OrderItemCommand> items
+    ) {
+        return items.stream()
+                .map(OrderPlaceCommand.OrderItemCommand::productId)
+                .sorted()
+                .toList();
+    }
+
+    /**
+     * 상품 리스트를 Map으로 변환
+     */
+    private Map<Long, Product> toProductMap(List<Product> products) {
+        return products.stream()
+                .collect(Collectors.toMap(Product::getId, Function.identity()));
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java

@@ -11,9 +11,12 @@ public record OrderInfo(
         Long orderId,
         String userId,
         Long totalAmount,
+        Long discountAmount,
         OrderStatus status,
         ZonedDateTime paidAt,
-        List<OrderItemInfo> items
+        List<OrderItemInfo> items,
+        String paymentMethod,
+        Long paymentId
 ) {
     public record OrderItemInfo(
             Long productId,
@@ -33,16 +36,39 @@ public static OrderItemInfo from(OrderItem item) {
         }
     }
 
-    public static OrderInfo from(Order order) {
+    public static OrderInfo from(Order order, Long discountAmount) {
         return new OrderInfo(
                 order.getId(),
                 order.getUser().getUserIdValue(),
                 order.getTotalAmountValue(),
+                discountAmount != null ? discountAmount : 0L,
                 order.getStatus(),
                 order.getPaidAt(),
                 order.getOrderItems().stream()
                         .map(OrderItemInfo::from)
-                        .toList()
+                        .toList(),
+                null,
+                null
         );
     }
+
+    public static OrderInfo from(Order order, Long discountAmount, String paymentMethod, Long paymentId) {
+        return new OrderInfo(
+                order.getId(),
+                order.getUser().getUserIdValue(),
+                order.getTotalAmountValue(),
+                discountAmount != null ? discountAmount : 0L,
+                order.getStatus(),
+                order.getPaidAt(),
+                order.getOrderItems().stream()
+                        .map(OrderItemInfo::from)
+                        .toList(),
+                paymentMethod,
+                paymentId
+        );
+    }
+
+    public Long getFinalAmount() {
+        return totalAmount - discountAmount;
+    }
 }

apps/commerce-api/src/main/java/com/loopers/application/order/OrderPlaceCommand.java

@@ -5,10 +5,33 @@
 public record OrderPlaceCommand(
         String userId,
         List<OrderItemCommand> items,
-        Long couponId
+        Long couponId,
+        PaymentMethod paymentMethod,
+        CardInfo cardInfo
 ) {
     public record OrderItemCommand(
             Long productId,
             Integer quantity
-    ) {}
+    ) {
+    }
+
+    public record CardInfo(
+            String cardType,
+            String cardNo
+    ) {
+    }
+
+    public enum PaymentMethod {
+        POINT,
+        PG_CARD
+    }
+
+    public List<Long> getSortedProductIds() {
+        return items.stream()
+                .map(OrderItemCommand::productId)
+                .sorted()
+                .distinct()
+                .toList();
+    }
 }
+