[volume-4] API 구현 보강 및 트랜잭션을 활용한 동시성 문제 해결 (#99)

* Add GitHub Actions workflow for PR Agent

* Feature/misc api (#15)

* refactor: product 도메인의 likeCount 집계 방식을 배치 방식으로 변경

* refactor: CatalogProductFacade에서 발생하는 n+1 쿼리 수정

* refactor: SignUpFacade의 NPE 가능성 제거

* refactor: Brand 도메인 name 필드의 입력 검증 로직 추가

* refactor: Order도메인 내의 OrderItem을 불변 객체로 설정

* feat: 브랜드 정보 조회 API 추가

* feat: 상품 조회 API 추가

* feat: 좋아요 수 집계 로직 추가

* feat: 좋아요 API 추가

* feat: 구매 API 추가

* Feature/concurrency like (#16)

* test: 좋아요 동시성 테스트 로직 추가

* feat: like에 unique constraint 적용해서 동시성 이슈 발생하지 않도록 함

* Feature/coupon (#17)

* test: 쿠폰 관련 테스트 코드 추가

* feat: coupon 구현

* Feature/concurrency purchasing (#18)

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

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

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

* refactor: deadlock 문제 수정

---------

Co-authored-by: simplify-len <joenggyu0@gmail.com>

Author: minor7295

.github/workflows/main.yml

@@ -0,0 +1,13 @@
+name: PR Agent
+on:
+  pull_request:
+    types: [opened, synchronize]
+jobs:
+  pr_agent_job:
+    runs-on: ubuntu-latest
+    steps:
+      - name: PR Agent action step
+        uses: Codium-ai/pr-agent@main
+        env:
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
+          GITHUB_TOKEN: ${{ secrets.G_TOKEN }}

apps/commerce-api/build.gradle.kts

@@ -11,6 +11,9 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
+    // batch
+    implementation("org.springframework.boot:spring-boot-starter-batch")
+
     // querydsl
     annotationProcessor("com.querydsl:querydsl-apt::jakarta")
     annotationProcessor("jakarta.persistence:jakarta.persistence-api")

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

@@ -4,10 +4,12 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
+import org.springframework.scheduling.annotation.EnableScheduling;
 import java.util.TimeZone;
 
 @ConfigurationPropertiesScan
 @SpringBootApplication
+@EnableScheduling
 public class CommerceApiApplication {
 
     @PostConstruct

apps/commerce-api/src/main/java/com/loopers/application/catalog/CatalogBrandFacade.java

@@ -0,0 +1,55 @@
+package com.loopers.application.catalog;
+
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.brand.BrandRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+/**
+ * 브랜드 조회 파사드.
+ * <p>
+ * 브랜드 정보 조회 유즈케이스를 처리하는 애플리케이션 서비스입니다.
+ * </p>
+ *
+ * @author Loopers
+ * @version 1.0
+ */
+@RequiredArgsConstructor
+@Component
+public class CatalogBrandFacade {
+    private final BrandRepository brandRepository;
+
+    /**
+     * 브랜드 정보를 조회합니다.
+     *
+     * @param brandId 브랜드 ID
+     * @return 브랜드 정보
+     * @throws CoreException 브랜드를 찾을 수 없는 경우
+     */
+    public BrandInfo getBrand(Long brandId) {
+        Brand brand = brandRepository.findById(brandId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."));
+        return BrandInfo.from(brand);
+    }
+
+    /**
+     * 브랜드 정보를 담는 레코드.
+     *
+     * @param id 브랜드 ID
+     * @param name 브랜드 이름
+     */
+    public record BrandInfo(Long id, String name) {
+        /**
+         * Brand 엔티티로부터 BrandInfo를 생성합니다.
+         *
+         * @param brand 브랜드 엔티티
+         * @return 생성된 BrandInfo
+         */
+        public static BrandInfo from(Brand brand) {
+            return new BrandInfo(brand.getId(), brand.getName());
+        }
+    }
+}
+

apps/commerce-api/src/main/java/com/loopers/application/catalog/CatalogProductFacade.java

@@ -2,17 +2,14 @@
 
 import com.loopers.domain.brand.Brand;
 import com.loopers.domain.brand.BrandRepository;
-import com.loopers.domain.like.LikeRepository;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductDetail;
-import com.loopers.domain.product.ProductDetailService;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
-import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -31,11 +28,12 @@
 public class CatalogProductFacade {
     private final ProductRepository productRepository;
     private final BrandRepository brandRepository;
-    private final LikeRepository likeRepository;
-    private final ProductDetailService productDetailService;
 
     /**
      * 상품 목록을 조회합니다.
+     * <p>
+     * 배치 조회를 통해 N+1 쿼리 문제를 해결합니다.
+     * </p>
      *
      * @param brandId 브랜드 ID (선택)
      * @param sort 정렬 기준 (latest, price_asc, likes_desc)
@@ -46,9 +44,36 @@ public class CatalogProductFacade {
     public ProductInfoList getProducts(Long brandId, String sort, int page, int size) {
         long totalCount = productRepository.countAll(brandId);
         List<Product> products = productRepository.findAll(brandId, sort, page, size);
+        
+        if (products.isEmpty()) {
+            return new ProductInfoList(List.of(), totalCount, page, size);
+        }
+        
+        // ✅ 배치 조회로 N+1 쿼리 문제 해결
+        // 브랜드 ID 수집
+        List<Long> brandIds = products.stream()
+            .map(Product::getBrandId)
+            .distinct()
+            .toList();
+        
+        // 브랜드 배치 조회 및 Map으로 변환 (O(1) 조회를 위해)
+        Map<Long, Brand> brandMap = brandRepository.findAllById(brandIds).stream()
+            .collect(Collectors.toMap(Brand::getId, brand -> brand));
+        
+        // 상품 정보 변환 (이미 조회한 Product 재사용)
         List<ProductInfo> productsInfo = products.stream()
-            .map(product -> getProduct(product.getId()))
+            .map(product -> {
+                Brand brand = brandMap.get(product.getBrandId());
+                if (brand == null) {
+                    throw new CoreException(ErrorType.NOT_FOUND,
+                        String.format("브랜드를 찾을 수 없습니다. (브랜드 ID: %d)", product.getBrandId()));
+                }
+                // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
+                ProductDetail productDetail = ProductDetail.from(product, brand.getName(), product.getLikeCount());
+                return new ProductInfo(productDetail);
+            })
             .toList();
+        
         return new ProductInfoList(productsInfo, totalCount, page, size);
     }
 
@@ -67,12 +92,11 @@ public ProductInfo getProduct(Long productId) {
         Brand brand = brandRepository.findById(product.getBrandId())
             .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."));
 
-        // 좋아요 수 조회
-        Map<Long, Long> likesCountMap = likeRepository.countByProductIds(List.of(productId));
-        Long likesCount = likesCountMap.getOrDefault(productId, 0L);
+        // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
+        Long likesCount = product.getLikeCount();
 
-        // 도메인 서비스를 통해 ProductDetail 생성 (도메인 객체 협력)
-        ProductDetail productDetail = productDetailService.combineProductAndBrand(product, brand, likesCount);
+        // ProductDetail 생성 (Aggregate 경계 준수: Brand 엔티티 대신 brandName만 전달)
+        ProductDetail productDetail = ProductDetail.from(product, brand.getName(), likesCount);
 
         return new ProductInfo(productDetail);
     }

apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java

@@ -8,13 +8,14 @@
 import com.loopers.domain.user.UserRepository;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
-import jakarta.transaction.Transactional;
+import org.springframework.transaction.annotation.Transactional;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * 좋아요 관리 파사드.
@@ -37,23 +38,52 @@ public class LikeFacade {
      * <p>
      * 멱등성을 보장합니다. 이미 좋아요가 존재하는 경우 아무 작업도 수행하지 않습니다.
      * </p>
+     * <p>
+     * <b>동시성 제어 전략:</b>
+     * <ul>
+     *   <li><b>UNIQUE 제약조건 사용:</b> 데이터베이스 레벨에서 중복 삽입을 물리적으로 방지</li>
+     *   <li><b>애플리케이션 레벨 한계:</b> 애플리케이션 레벨로는 race condition을 완전히 방지할 수 없음</li>
+     *   <li><b>예외 처리:</b> UNIQUE 제약조건 위반 시 DataIntegrityViolationException 처리하여 멱등성 보장</li>
+     * </ul>
+     * </p>
+     * <p>
+     * <b>DBA 설득 근거 (유니크 인덱스 사용):</b>
+     * <ul>
+     *   <li><b>트래픽 패턴:</b> 좋아요는 고 QPS write-heavy 테이블이 아니며, 전체 서비스에서 차지하는 비중이 낮음</li>
+     *   <li><b>애플리케이션 레벨 한계:</b> 동일 시점 동시 요청 시 select 시점엔 중복 없음 → insert 2번 발생 가능</li>
+     *   <li><b>데이터 무결성:</b> DB만이 강한 무결성(Strong Consistency)을 제공할 수 있음</li>
+     *   <li><b>비즈니스 데이터 보호:</b> 중복 좋아요로 인한 비즈니스 데이터 오염 방지</li>
+     * </ul>
+     * </p>
      *
      * @param userId 사용자 ID (String)
      * @param productId 상품 ID
      * @throws CoreException 사용자 또는 상품을 찾을 수 없는 경우
      */
-    @Transactional
     public void addLike(String userId, Long productId) {
         User user = loadUser(userId);
         loadProduct(productId);
 
+        // 먼저 일반 조회로 중복 체크 (대부분의 경우 빠르게 처리)
+        // ⚠️ 주의: 애플리케이션 레벨 체크만으로는 race condition을 완전히 방지할 수 없음
+        // 동시에 두 요청이 들어오면 둘 다 "없음"으로 판단 → 둘 다 저장 시도 가능
         Optional<Like> existingLike = likeRepository.findByUserIdAndProductId(user.getId(), productId);
         if (existingLike.isPresent()) {
             return;
         }
 
+        // 저장 시도 (동시성 상황에서는 UNIQUE 제약조건 위반 예외 발생 가능)
+        // ✅ UNIQUE 제약조건이 최종 보호: DB 레벨에서 중복 삽입을 물리적으로 방지
+        // @Transactional이 없어도 save() 호출 시 자동 트랜잭션으로 예외를 catch할 수 있음
         Like like = Like.of(user.getId(), productId);
-        likeRepository.save(like);
+        try {
+            likeRepository.save(like);
+        } catch (org.springframework.dao.DataIntegrityViolationException e) {
+            // UNIQUE 제약조건 위반 = 이미 저장됨 (멱등성 보장)
+            // 동시에 여러 요청이 들어와서 모두 "없음"으로 판단하고 저장을 시도할 때,
+            // 첫 번째만 성공하고 나머지는 UNIQUE 제약조건 위반 예외 발생
+            // 이미 좋아요가 존재하는 경우이므로 정상 처리로 간주
+        }
     }
 
     /**
@@ -66,7 +96,6 @@ public void addLike(String userId, Long productId) {
      * @param productId 상품 ID
      * @throws CoreException 사용자 또는 상품을 찾을 수 없는 경우
      */
-    @Transactional
     public void removeLike(String userId, Long productId) {
         User user = loadUser(userId);
         loadProduct(productId);
@@ -76,16 +105,33 @@ public void removeLike(String userId, Long productId) {
             return;
         }
 
-        likeRepository.delete(like.get());
+        try {
+            likeRepository.delete(like.get());
+        } catch (Exception e) {
+            // 동시성 상황에서 이미 삭제된 경우 등 예외 발생 가능
+            // 멱등성 보장: 이미 삭제된 경우 정상 처리로 간주
+        }
     }
 
     /**
      * 사용자가 좋아요한 상품 목록을 조회합니다.
+     * <p>
+     * 상품 정보 조회를 병렬로 처리하여 성능을 최적화합니다.
+     * </p>
+     * <p>
+     * <b>좋아요 수 조회 전략:</b>
+     * <ul>
+     *   <li><b>비동기 집계:</b> Product.likeCount 필드 사용 (스케줄러로 주기적 동기화)</li>
+     *   <li><b>Eventually Consistent:</b> 약간의 지연 허용 (최대 5초)</li>
+     *   <li><b>성능 최적화:</b> COUNT(*) 쿼리 없이 컬럼만 읽으면 됨</li>
+     * </ul>
+     * </p>
      *
      * @param userId 사용자 ID (String)
      * @return 좋아요한 상품 목록
      * @throws CoreException 사용자를 찾을 수 없는 경우
      */
+    @Transactional(readOnly = true)
     public List<LikedProduct> getLikedProducts(String userId) {
         User user = loadUser(userId);
 
@@ -101,26 +147,26 @@ public List<LikedProduct> getLikedProducts(String userId) {
             .map(Like::getProductId)
             .toList();
 
-        // 상품 정보 조회
-        List<Product> products = productIds.stream()
-            .map(productId -> productRepository.findById(productId)
-                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
-                    String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", productId))))
-            .toList();
+        // ✅ 배치 조회로 N+1 쿼리 문제 해결
+        Map<Long, Product> productMap = productRepository.findAllById(productIds).stream()
+            .collect(Collectors.toMap(Product::getId, product -> product));
 
-        // 좋아요 수 집계
-        Map<Long, Long> likesCountMap = likeRepository.countByProductIds(productIds);
+        // 요청한 상품 ID와 조회된 상품 수가 일치하는지 확인
+        if (productMap.size() != productIds.size()) {
+            throw new CoreException(ErrorType.NOT_FOUND, "일부 상품을 찾을 수 없습니다.");
+        }
 
         // 좋아요 목록을 상품 정보와 좋아요 수와 함께 변환
+        // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
         return likes.stream()
             .map(like -> {
-                Product product = products.stream()
-                    .filter(p -> p.getId().equals(like.getProductId()))
-                    .findFirst()
-                    .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
-                        String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", like.getProductId())));
-                Long likesCount = likesCountMap.getOrDefault(like.getProductId(), 0L);
-                return LikedProduct.from(product, like, likesCount);
+                Product product = productMap.get(like.getProductId());
+                if (product == null) {
+                    throw new CoreException(ErrorType.NOT_FOUND,
+                        String.format("상품을 찾을 수 없습니다. (상품 ID: %d)", like.getProductId()));
+                }
+                // Product 엔티티의 likeCount 필드를 내부에서 사용
+                return LikedProduct.from(product);
             })
             .toList();
     }
@@ -158,21 +204,26 @@ public record LikedProduct(
         Long likesCount
     ) {
         /**
-         * Product와 Like로부터 LikedProduct를 생성합니다.
+         * Product로부터 LikedProduct를 생성합니다.
+         * <p>
+         * Product.likeCount 필드를 사용하여 좋아요 수를 가져옵니다.
+         * </p>
          *
          * @param product 상품 엔티티
-         * @param like 좋아요 엔티티
-         * @param likesCount 좋아요 수
          * @return 생성된 LikedProduct
+         * @throws IllegalArgumentException product가 null인 경우
          */
-        public static LikedProduct from(Product product, Like like, Long likesCount) {
+        public static LikedProduct from(Product product) {
+            if (product == null) {
+                throw new IllegalArgumentException("상품은 null일 수 없습니다.");
+            }
             return new LikedProduct(
                 product.getId(),
                 product.getName(),
                 product.getPrice(),
                 product.getStock(),
                 product.getBrandId(),
-                likesCount
+                product.getLikeCount() // ✅ Product.likeCount 필드 사용 (비동기 집계된 값)
             );
         }
     }

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

@@ -8,8 +8,9 @@
  *
  * @param productId 상품 ID
  * @param quantity 수량
+ * @param couponCode 쿠폰 코드 (선택)
  */
-public record OrderItemCommand(Long productId, Integer quantity) {
+public record OrderItemCommand(Long productId, Integer quantity, String couponCode) {
     public OrderItemCommand {
         if (productId == null) {
             throw new CoreException(ErrorType.BAD_REQUEST, "상품 ID는 필수입니다.");
@@ -18,5 +19,16 @@ public record OrderItemCommand(Long productId, Integer quantity) {
             throw new CoreException(ErrorType.BAD_REQUEST, "상품 수량은 1개 이상이어야 합니다.");
         }
     }
+
+    /**
+     * 쿠폰 코드 없이 OrderItemCommand를 생성합니다.
+     *
+     * @param productId 상품 ID
+     * @param quantity 수량
+     * @return 생성된 OrderItemCommand
+     */
+    public static OrderItemCommand of(Long productId, Integer quantity) {
+        return new OrderItemCommand(productId, quantity, null);
+    }
 }