Feature/concurrency purchasing (#18)

* test: 주문 동시성 테스트 로직 추가

* test: 주문 흐름의 원자성을 검증하는 테스트 코드 추가

* feat: 비관적 락 적용하여 주문 동시성 이슈 발생하지 않도록 함

* refactor: deadlock 문제 수정

Author: minor7295

apps/commerce-api/src/main/java/com/loopers/application/purchasing/PurchasingFacade.java

@@ -21,11 +21,9 @@
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -97,23 +95,39 @@ public OrderInfo createOrder(String userId, List<OrderItemCommand> commands) {
         // - 트랜잭션 내부에 외부 I/O 없음, lock holding time 매우 짧음
         User user = loadUserForUpdate(userId);
 
-        Set<Long> productIds = new HashSet<>();
-        List<Product> products = new ArrayList<>();
-        List<OrderItem> orderItems = new ArrayList<>();
+        // ✅ Deadlock 방지: 상품 ID를 정렬하여 일관된 락 획득 순서 보장
+        // 여러 상품을 주문할 때, 항상 동일한 순서로 락을 획득하여 deadlock 방지
+        List<Long> sortedProductIds = commands.stream()
+            .map(OrderItemCommand::productId)
+            .distinct()
+            .sorted()
+            .toList();
 
-        for (OrderItemCommand command : commands) {
-            if (!productIds.add(command.productId())) {
-                throw new CoreException(ErrorType.BAD_REQUEST,
-                    String.format("상품이 중복되었습니다. (상품 ID: %d)", command.productId()));
-            }
+        // 중복 상품 검증
+        if (sortedProductIds.size() != commands.size()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "상품이 중복되었습니다.");
+        }
+
+        // 정렬된 순서대로 상품 락 획득 (Deadlock 방지)
+        Map<Long, Product> productMap = new java.util.HashMap<>();
 
+        for (Long productId : sortedProductIds) {
             // 비관적 락을 사용하여 상품 조회 (재고 차감 시 동시성 제어)
             // - id는 PK 인덱스가 있어 Lock 범위 최소화 (Record Lock만 적용)
             // - Lost Update 방지: 동시 주문 시 재고 음수 방지 및 정확한 차감 보장 (재고 oversell 방지)
             // - 트랜잭션 내부에 외부 I/O 없음, lock holding time 매우 짧음
-            Product product = productRepository.findByIdForUpdate(command.productId())
+            // - ✅ 정렬된 순서로 락 획득하여 deadlock 방지
+            Product product = productRepository.findByIdForUpdate(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
-                    String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", command.productId())));
+                    String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", productId)));
+            productMap.put(productId, product);
+        }
+
+        // OrderItem 생성
+        List<Product> products = new ArrayList<>();
+        List<OrderItem> orderItems = new ArrayList<>();
+        for (OrderItemCommand command : commands) {
+            Product product = productMap.get(command.productId());
             products.add(product);
 
             orderItems.add(OrderItem.of(
@@ -147,6 +161,13 @@ public OrderInfo createOrder(String userId, List<OrderItemCommand> commands) {
 
     /**
      * 주문을 취소하고 포인트를 환불하며 재고를 원복한다.
+     * <p>
+     * <b>동시성 제어:</b>
+     * <ul>
+     *   <li><b>비관적 락 사용:</b> 재고 원복 시 동시성 제어를 위해 findByIdForUpdate 사용</li>
+     *   <li><b>Deadlock 방지:</b> 상품 ID를 정렬하여 일관된 락 획득 순서 보장</li>
+     * </ul>
+     * </p>
      *
      * @param order 주문 엔티티
      * @param user 사용자 엔티티
@@ -157,18 +178,41 @@ public void cancelOrder(Order order, User user) {
             throw new CoreException(ErrorType.BAD_REQUEST, "취소할 주문과 사용자 정보는 필수입니다.");
         }
 
-        List<Product> products = order.getItems().stream()
-            .map(item -> productRepository.findById(item.getProductId())
+        // ✅ Deadlock 방지: User 락을 먼저 획득하여 createOrder와 동일한 락 획득 순서 보장
+        // createOrder: User 락 → Product 락 (정렬됨)
+        // cancelOrder: User 락 → Product 락 (정렬됨) - 동일한 순서로 락 획득
+        User lockedUser = userRepository.findByUserIdForUpdate(user.getUserId());
+        if (lockedUser == null) {
+            throw new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다.");
+        }
+
+        // ✅ Deadlock 방지: 상품 ID를 정렬하여 일관된 락 획득 순서 보장
+        List<Long> sortedProductIds = order.getItems().stream()
+            .map(OrderItem::getProductId)
+            .distinct()
+            .sorted()
+            .toList();
+
+        // 정렬된 순서대로 상품 락 획득 (Deadlock 방지)
+        Map<Long, Product> productMap = new java.util.HashMap<>();
+        for (Long productId : sortedProductIds) {
+            Product product = productRepository.findByIdForUpdate(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
-                    String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", item.getProductId()))))
+                    String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", productId)));
+            productMap.put(productId, product);
+        }
+
+        // OrderItem 순서대로 Product 리스트 생성
+        List<Product> products = order.getItems().stream()
+            .map(item -> productMap.get(item.getProductId()))
             .toList();
 
         order.cancel();
         increaseStocksForOrderItems(order.getItems(), products);
-        user.receivePoint(Point.of((long) order.getTotalAmount()));
+        lockedUser.receivePoint(Point.of((long) order.getTotalAmount()));
 
         products.forEach(productRepository::save);
-        userRepository.save(user);
+        userRepository.save(lockedUser);
         orderRepository.save(order);
     }
 

apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItem.java

@@ -15,7 +15,6 @@
  */
 @Getter
 @EqualsAndHashCode
-@Embeddable
 public class OrderItem {
     private Long productId;
     private String name;

apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java

@@ -25,4 +25,23 @@ public interface UserRepository {
      * @return 조회된 사용자, 없으면 null
      */
     User findByUserId(String userId);
+
+    /**
+     * 사용자 ID로 사용자를 조회합니다. (비관적 락)
+     * <p>
+     * 동시성 제어가 필요한 경우 사용합니다. (예: 포인트 차감)
+     * </p>
+     * <p>
+     * <b>Lock 전략:</b>
+     * <ul>
+     *   <li><b>PESSIMISTIC_WRITE:</b> SELECT ... FOR UPDATE 사용</li>
+     *   <li><b>Lock 범위:</b> UNIQUE(userId) 인덱스 기반 조회로 해당 행만 락 (최소화)</li>
+     *   <li><b>사용 목적:</b> 포인트 차감 시 Lost Update 방지</li>
+     * </ul>
+     * </p>
+     *
+     * @param userId 조회할 사용자 ID
+     * @return 조회된 사용자, 없으면 null
+     */
+    User findByUserIdForUpdate(String userId);
 }

apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java

@@ -1,7 +1,12 @@
 package com.loopers.infrastructure.user;
 
 import com.loopers.domain.user.User;
+import jakarta.persistence.LockModeType;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
 import java.util.Optional;
 
 /**
@@ -22,4 +27,34 @@ public interface UserJpaRepository extends JpaRepository<User, Long> {
      * @return 조회된 사용자를 담은 Optional
      */
     Optional<User> findByUserId(String userId);
+
+    /**
+     * 사용자 ID로 사용자를 조회합니다. (비관적 락)
+     * <p>
+     * SELECT ... FOR UPDATE를 사용하여 동시성 제어를 보장합니다.
+     * </p>
+     * <p>
+     * <b>Lock 전략:</b>
+     * <ul>
+     *   <li><b>PESSIMISTIC_WRITE 선택 근거:</b> 포인트 차감 시 Lost Update 방지</li>
+     *   <li><b>Lock 범위 최소화:</b> UNIQUE(userId) 인덱스 기반 조회로 해당 행만 락</li>
+     *   <li><b>인덱스 활용:</b> UNIQUE 제약조건으로 인덱스가 자동 생성되어 Lock 범위 최소화</li>
+     * </ul>
+     * </p>
+     * <p>
+     * <b>동작 원리:</b>
+     * <ol>
+     *   <li>SELECT ... FOR UPDATE 실행 → 해당 행에 배타적 락 설정</li>
+     *   <li>다른 트랜잭션의 쓰기/FOR UPDATE는 차단 (일반 읽기는 가능)</li>
+     *   <li>포인트 차감 후 트랜잭션 커밋 → 락 해제</li>
+     *   <li>대기 중이던 트랜잭션이 최신 값을 읽어 처리</li>
+     * </ol>
+     * </p>
+     *
+     * @param userId 조회할 사용자 ID
+     * @return 조회된 사용자를 담은 Optional
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT u FROM User u WHERE u.userId = :userId")
+    Optional<User> findByUserIdForUpdate(@Param("userId") String userId);
 }

apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java

@@ -35,4 +35,12 @@ public User save(User user) {
     public User findByUserId(String userId) {
         return userJpaRepository.findByUserId(userId).orElse(null);
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public User findByUserIdForUpdate(String userId) {
+        return userJpaRepository.findByUserIdForUpdate(userId).orElse(null);
+    }
 }