[volume - 5] 인덱스 추가 및 캐시 설계 - 김윤선

CLAUDE.md

@@ -132,6 +132,11 @@
 - 요구사항 분석, 설계 문서 작성 요청 시 해당 파일을 Read 도구로 읽고 지침을 따를 것
 - 시퀀스 다이어그램, 클래스 다이어그램, ERD 작성 시 Mermaid 문법 사용
 
+### 조회 API 설계 리뷰
+- 파일: `.claude/skills/read-optimization-review/SKILL.md`
+- 조회 API 설계 검토, 캐시 전략 리뷰, 읽기 최적화 리뷰 요청 시 해당 파일을 Read 도구로 읽고 지침을 따를 것
+- 구조적 리스크와 trade-off 관점에서만 분석하며, 구현 코드나 설정 값은 제안하지 않음
+
 
 ## 도메인 & 객체 설계 전략
 - 도메인 객체는 비즈니스 규칙을 캡슐화해야 합니다.

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

@@ -8,6 +8,7 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.user.UserRepository;
+import com.loopers.infrastructure.product.ProductCacheStore;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import jakarta.persistence.OptimisticLockException;
@@ -36,6 +37,7 @@ public class LikeFacade {
     private final UserRepository userRepository;
     private final BrandRepository brandRepository;
     private final LikeService likeService;
+    private final ProductCacheStore productCacheStore;
 
     @Transactional
     @Retryable(
@@ -80,6 +82,7 @@ public LikeDto.LikeResult likeWithStatus(Long userId, Long productId) {
         product.increaseLikeCount();
         Like saved = likeRepository.save(result.like());
         productRepository.save(product);
+        productCacheStore.evictProduct(productId);
         return new LikeDto.LikeResult(LikeDto.LikeInfo.from(saved), false);
     }
 
@@ -109,6 +112,7 @@ public void unlike(Long userId, Long productId) {
         product.decreaseLikeCount();
         likeRepository.save(like);
         productRepository.save(product);
+        productCacheStore.evictProduct(productId);
     }
 
     @Transactional(readOnly = true)

apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java

@@ -7,6 +7,7 @@
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.product.exception.ProductInsufficientStockException;
 import com.loopers.domain.product.exception.ProductNotDeletedException;
+import com.loopers.infrastructure.product.ProductCacheStore;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -28,6 +29,7 @@ public class ProductFacade {
     private final ProductRepository productRepository;
     private final BrandRepository brandRepository;
     private final ProductService productService;
+    private final ProductCacheStore productCacheStore;
 
     @Transactional
     public ProductDto.ProductInfo register(Long brandId, String name, String description, BigDecimal price, Integer stock) {
@@ -58,43 +60,65 @@ public ProductDto.ProductInfo update(Long productId, String name, String descrip
         Product saved = productRepository.save(product);
         Brand brand = brandRepository.findById(saved.getBrandId())
             .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+        productCacheStore.evictProduct(productId);
         return ProductDto.ProductInfo.of(saved, brand.getName());
     }
 
     @Transactional(readOnly = true)
     public Page<ProductDto.ProductInfo> getProducts(ProductSortType sortType, Pageable pageable) {
-        Pageable sorted = PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), sortType.toSort());
-        Page<Product> products = productRepository.findAll(sorted);
-
-        Set<Long> brandIds = products.stream()
-            .map(Product::getBrandId)
-            .collect(Collectors.toSet());
-
-        Map<Long, String> brandNameMap = brandRepository.findAllByIds(brandIds).stream()
-            .collect(Collectors.toMap(Brand::getId, Brand::getName));
-
-        return products.map(product ->
-            ProductDto.ProductInfo.of(product, brandNameMap.getOrDefault(product.getBrandId(), ""))
-        );
+        int page = pageable.getPageNumber();
+        int size = pageable.getPageSize();
+
+        return productCacheStore.getProductList(null, sortType, page, size)
+            .orElseGet(() -> {
+                Pageable sorted = PageRequest.of(page, size, sortType.toSort());
+                Page<Product> products = productRepository.findAll(sorted);
+
+                Set<Long> brandIds = products.stream()
+                    .map(Product::getBrandId)
+                    .collect(Collectors.toSet());
+
+                Map<Long, String> brandNameMap = brandRepository.findAllByIds(brandIds).stream()
+                    .collect(Collectors.toMap(Brand::getId, Brand::getName));
+
+                Page<ProductDto.ProductInfo> result = products.map(product ->
+                    ProductDto.ProductInfo.of(product, brandNameMap.getOrDefault(product.getBrandId(), ""))
+                );
+                productCacheStore.putProductList(null, sortType, page, size, result);
+                return result;
+            });
     }
 
     @Transactional(readOnly = true)
     public Page<ProductDto.ProductInfo> getProductsByBrand(Long brandId, ProductSortType sortType, Pageable pageable) {
-        Brand brand = brandRepository.findById(brandId)
-            .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
-
-        Pageable sorted = PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), sortType.toSort());
-        return productRepository.findByBrandId(brandId, sorted)
-            .map(product -> ProductDto.ProductInfo.of(product, brand.getName()));
+        int page = pageable.getPageNumber();
+        int size = pageable.getPageSize();
+
+        return productCacheStore.getProductList(brandId, sortType, page, size)
+            .orElseGet(() -> {
+                Brand brand = brandRepository.findById(brandId)
+                    .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+
+                Pageable sorted = PageRequest.of(page, size, sortType.toSort());
+                Page<ProductDto.ProductInfo> result = productRepository.findByBrandId(brandId, sorted)
+                    .map(product -> ProductDto.ProductInfo.of(product, brand.getName()));
+                productCacheStore.putProductList(brandId, sortType, page, size, result);
+                return result;
+            });
     }
 
     @Transactional(readOnly = true)
     public ProductDto.ProductInfo getProduct(Long productId) {
-        Product product = productRepository.findById(productId)
-            .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
-        Brand brand = brandRepository.findById(product.getBrandId())
-            .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
-        return ProductDto.ProductInfo.of(product, brand.getName());
+        return productCacheStore.getProduct(productId)
+            .orElseGet(() -> {
+                Product product = productRepository.findById(productId)
+                    .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
+                Brand brand = brandRepository.findById(product.getBrandId())
+                    .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+                ProductDto.ProductInfo info = ProductDto.ProductInfo.of(product, brand.getName());
+                productCacheStore.putProduct(productId, info);
+                return info;
+            });
     }
 
     @Transactional
@@ -105,6 +129,7 @@ public ProductDto.ProductInfo increaseStock(Long productId, Integer quantity) {
         Product saved = productRepository.save(product);
         Brand brand = brandRepository.findById(saved.getBrandId())
             .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+        productCacheStore.evictProduct(productId);
         return ProductDto.ProductInfo.of(saved, brand.getName());
     }
 
@@ -120,6 +145,7 @@ public ProductDto.ProductInfo decreaseStock(Long productId, Integer quantity) {
         Product saved = productRepository.save(product);
         Brand brand = brandRepository.findById(saved.getBrandId())
             .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+        productCacheStore.evictProduct(productId);
         return ProductDto.ProductInfo.of(saved, brand.getName());
     }
 
@@ -129,6 +155,7 @@ public void delete(Long productId) {
             .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
         productService.deleteProduct(product);
         productRepository.save(product);
+        productCacheStore.evictProduct(productId);
     }
 
     @Transactional
@@ -144,6 +171,7 @@ public ProductDto.ProductInfo restore(Long productId) {
         Product saved = productRepository.save(product);
         Brand brand = brandRepository.findByIdIncludingDeleted(saved.getBrandId())
             .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
+        productCacheStore.evictProduct(productId);
         return ProductDto.ProductInfo.of(saved, brand.getName());
     }
 

apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java

@@ -4,14 +4,22 @@
 import com.loopers.domain.product.exception.ProductInsufficientStockException;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.Index;
 import jakarta.persistence.Table;
 import jakarta.persistence.Version;
 import lombok.Getter;
 
 import java.math.BigDecimal;
 
 @Entity
-@Table(name = "products")
+@Table(
+    name = "products",
+    indexes = {
+        @Index(name = "idx_products_brand_id_like_count", columnList = "brand_id, like_count DESC"),
+        @Index(name = "idx_products_brand_id_created_at", columnList = "brand_id, created_at DESC"),
+        @Index(name = "idx_products_brand_id_price", columnList = "brand_id, price ASC")
+    }
+)
 @Getter
 public class Product extends BaseEntity {
 

apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductCacheStore.java

@@ -0,0 +1,86 @@
+package com.loopers.infrastructure.product;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.application.product.ProductDto;
+import com.loopers.application.product.ProductSortType;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ProductCacheStore {
+
+    private static final String PRODUCT_KEY_PREFIX = "product:";
+    private static final String PRODUCT_LIST_KEY_PREFIX = "product:list:";
+    private static final Duration PRODUCT_TTL = Duration.ofHours(1);
+    private static final Duration PRODUCT_LIST_TTL = Duration.ofMinutes(1);
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    public Optional<ProductDto.ProductInfo> getProduct(Long productId) {
+        try {
+            String json = redisTemplate.opsForValue().get(productKey(productId));
+            if (json == null) return Optional.empty();
+            return Optional.of(objectMapper.readValue(json, ProductDto.ProductInfo.class));
+        } catch (Exception e) {
+            log.warn("캐시 조회 실패 - product:{}", productId, e);
+            return Optional.empty();
+        }
+    }
+
+    public void putProduct(Long productId, ProductDto.ProductInfo info) {
+        try {
+            String json = objectMapper.writeValueAsString(info);
+            redisTemplate.opsForValue().set(productKey(productId), json, PRODUCT_TTL);
+        } catch (Exception e) {
+            log.warn("캐시 저장 실패 - product:{}", productId, e);
+        }
+    }
+
+    public void evictProduct(Long productId) {
+        redisTemplate.delete(productKey(productId));
+    }
+
+    public Optional<Page<ProductDto.ProductInfo>> getProductList(Long brandId, ProductSortType sortType, int page, int size) {
+        try {
+            String json = redisTemplate.opsForValue().get(listKey(brandId, sortType, page, size));
+            if (json == null) return Optional.empty();
+            ProductListCache cache = objectMapper.readValue(json, ProductListCache.class);
+            return Optional.of(new PageImpl<>(cache.content(), PageRequest.of(page, size), cache.totalElements()));
+        } catch (Exception e) {
+            log.warn("캐시 조회 실패 - product list brand:{} sort:{} page:{}", brandId, sortType, page, e);
+            return Optional.empty();
+        }
+    }
+
+    public void putProductList(Long brandId, ProductSortType sortType, int page, int size, Page<ProductDto.ProductInfo> result) {
+        try {
+            ProductListCache cache = new ProductListCache(result.getContent(), result.getTotalElements());
+            String json = objectMapper.writeValueAsString(cache);
+            redisTemplate.opsForValue().set(listKey(brandId, sortType, page, size), json, PRODUCT_LIST_TTL);
+        } catch (Exception e) {
+            log.warn("캐시 저장 실패 - product list brand:{} sort:{} page:{}", brandId, sortType, page, e);
+        }
+    }
+
+    private String productKey(Long id) {
+        return PRODUCT_KEY_PREFIX + id;
+    }
+
+    private String listKey(Long brandId, ProductSortType sortType, int page, int size) {
+        return PRODUCT_LIST_KEY_PREFIX + "brand=" + brandId + ":sort=" + sortType + ":page=" + page + ":size=" + size;
+    }
+
+    private record ProductListCache(List<ProductDto.ProductInfo> content, long totalElements) {}
+}

apps/commerce-api/src/test/java/com/loopers/application/like/LikeFacadeIntegrationTest.java

@@ -181,7 +181,7 @@ void like_concurrent_likeCount() throws InterruptedException {
         List<Long> userIds = new ArrayList<>();
         for (int i = 0; i < concurrency; i++) {
             UserDto.UserInfo u = userFacade.register(
-                "likeuser" + i, "TestPass1!", "좋아요유저" + i,
+                "likeuser" + i, "TestPass1!", "좋아요유저",
                 LocalDate.of(2000, 1, 1), "like" + i + "@loopers.com", Gender.MALE
             );
             userIds.add(u.id());
@@ -218,4 +218,50 @@ void like_concurrent_likeCount() throws InterruptedException {
         Product product = productRepository.findById(productId).orElseThrow();
         assertThat(product.getLikeCount()).isEqualTo(concurrency);
     }
+
+    @DisplayName("동일한 상품에 여러 명이 동시에 좋아요 취소를 해도 likeCount가 정상 반영된다")
+    @Test
+    void unlike_concurrent_likeCount() throws InterruptedException {
+        int concurrency = 3;
+        List<Long> userIds = new ArrayList<>();
+        for (int i = 0; i < concurrency; i++) {
+            UserDto.UserInfo u = userFacade.register(
+                "unlike" + i, "TestPass1!", "취소유저",
+                LocalDate.of(2000, 1, 1), "unlike" + i + "@loopers.com", Gender.MALE
+            );
+            userIds.add(u.id());
+            likeFacade.like(u.id(), productId);
+        }
+
+        ExecutorService executor = Executors.newFixedThreadPool(concurrency);
+        CountDownLatch ready = new CountDownLatch(concurrency);
+        CountDownLatch start = new CountDownLatch(1);
+        CountDownLatch done = new CountDownLatch(concurrency);
+        List<Throwable> failures = Collections.synchronizedList(new ArrayList<>());
+
+        for (int i = 0; i < concurrency; i++) {
+            final Long uid = userIds.get(i);
+            executor.submit(() -> {
+                ready.countDown();
+                try {
+                    start.await();
+                    likeFacade.unlike(uid, productId);
+                } catch (Throwable t) {
+                    failures.add(t);
+                } finally {
+                    done.countDown();
+                }
+            });
+        }
+
+        assertThat(ready.await(5, TimeUnit.SECONDS)).isTrue();
+        start.countDown();
+        assertThat(done.await(15, TimeUnit.SECONDS)).isTrue();
+        executor.shutdown();
+        assertThat(executor.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+
+        assertThat(failures).isEmpty();
+        Product product = productRepository.findById(productId).orElseThrow();
+        assertThat(product.getLikeCount()).isZero();
+    }
 }

apps/commerce-api/src/test/java/com/loopers/application/like/LikeFacadeTest.java

@@ -8,6 +8,7 @@
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserRepository;
+import com.loopers.infrastructure.product.ProductCacheStore;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.BeforeEach;
@@ -44,7 +45,8 @@ void setUp() {
             productRepository,
             userRepository,
             brandRepository,
-            new LikeService()
+            new LikeService(),
+            mock(ProductCacheStore.class)
         );
     }
 

apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java

@@ -7,6 +7,7 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.infrastructure.product.ProductCacheStore;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.BeforeEach;
@@ -41,7 +42,8 @@ void setUp() {
         productFacade = new ProductFacade(
             productRepository,
             brandRepository,
-            new ProductService()
+            new ProductService(),
+            mock(ProductCacheStore.class)
         );
 
         brand = Brand.create(new BrandName("LOOPERS"), new BrandDescription("루퍼스 브랜드"));