[Volume 5] 상품 좋아요 MV 도입 및 상품 조회 Redis 캐싱 적용

CLAUDE.md

@@ -186,7 +186,27 @@ public class Product extends BaseEntity {
 - Facade: 다중 도메인 조합 시 `@Transactional`
 - 도메인 엔티티에는 `@Transactional` 사용 금지
 
-## 10. 테스트
+## 10. 캐시 규칙
+
+### 캐시 키 네이밍 컨벤션
+- 형식: `{도메인}:{식별자 또는 조건}` (콜론 구분, kebab-case 없이 소문자)
+- 단건: `{도메인}:{id}` — 예: `product:1`
+- 목록: `{도메인}s:{필터}:page:{page}:size:{size}:sort:{sort}` — 예: `products:brand:3:page:0:size:20:sort:createdAt,desc`
+- 필터 없는 전체 목록: `{도메인}s:all:page:{page}:size:{size}:sort:{sort}` — 예: `products:all:page:0:size:20:sort:createdAt,desc`
+
+### 캐시 무효화 전략
+| 이벤트 | 단건 캐시 (`{도메인}:{id}`) | 목록 캐시 (`{도메인}s:...`) |
+|--------|---------------------------|---------------------------|
+| 등록 | 해당 없음 | 관련 목록 캐시 삭제 |
+| 수정 | 해당 키 삭제 | 관련 목록 캐시 삭제 |
+| 삭제 | 해당 키 삭제 | 관련 목록 캐시 삭제 |
+
+### 캐시 인프라
+- 캐시 구현체는 `infrastructure` 계층에 `{Domain}CacheManager`로 위치
+- TTL: 도메인 특성에 따라 결정 (기본 1시간)
+- 직렬화: JSON (Jackson ObjectMapper)
+
+## 11. 테스트
 - 테스트 코드 생성 시 test-generate 스킬을 따른다.
 - 메서드명: 한국어, 유비쿼터스 언어 기반
 - 구조: given-when-then

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

@@ -1,7 +1,6 @@
 package com.loopers.application.like;
 
 import com.loopers.application.like.result.LikeResult;
-import com.loopers.application.product.ProductService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -11,18 +10,14 @@
 public class LikeFacade {
 
     private final LikeService likeService;
-    private final ProductService productService;
 
     @Transactional
     public LikeResult like(Long userId, Long productId) {
-        LikeResult result = likeService.like(userId, productId);
-        productService.incrementLikeCount(productId);
-        return result;
+        return likeService.like(userId, productId);
     }
 
     @Transactional
     public void unlike(Long userId, Long productId) {
         likeService.unlike(userId, productId);
-        productService.decrementLikeCount(productId);
     }
 }

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

@@ -3,6 +3,8 @@
 import com.loopers.application.like.result.LikeResult;
 import com.loopers.domain.like.ProductLike;
 import com.loopers.domain.like.ProductLikeRepository;
+import com.loopers.domain.like.ProductLikeCount;
+import com.loopers.domain.like.ProductLikeCountRepository;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -11,11 +13,16 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 @RequiredArgsConstructor
 @Service
 public class LikeService {
 
     private final ProductLikeRepository productLikeRepository;
+    private final ProductLikeCountRepository productLikesCountRepository;
 
     @Transactional
     public LikeResult like(Long userId, Long productId) {
@@ -48,4 +55,20 @@ public void unlike(Long userId, Long productId) {
     public void deleteLikes(Long productId) {
         productLikeRepository.deleteByProductId(productId);
     }
+
+    @Transactional(readOnly = true)
+    public int getLikeCount(Long productId) {
+        return productLikesCountRepository.findByProductId(productId)
+                .map(ProductLikeCount::getLikeCount)
+                .orElse(0);
+    }
+
+    @Transactional(readOnly = true)
+    public Map<Long, Integer> getLikeCounts(List<Long> productIds) {
+        return productLikesCountRepository.findByProductIdIn(productIds).stream()
+                .collect(Collectors.toMap(
+                        ProductLikeCount::getProductId,
+                        ProductLikeCount::getLikeCount
+                ));
+    }
 }

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

@@ -7,6 +7,7 @@
 import com.loopers.application.product.command.ProductUpdateCommand;
 import com.loopers.application.product.result.ProductResult;
 import com.loopers.application.product.result.ProductWithBrandResult;
+import com.loopers.application.product.result.ProductWithLikeCountResult;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -25,14 +26,16 @@ public class ProductFacade {
 
     @Transactional(readOnly = true)
     public ProductWithBrandResult getProduct(Long productId) {
-        ProductResult product = productService.getProduct(productId);
+        ProductWithLikeCountResult product = productService.getProductWithLikeCount(productId);
         BrandResult brand = brandService.getBrand(product.brandId());
         return ProductWithBrandResult.from(product, brand.name());
     }
 
     @Transactional(readOnly = true)
     public Page<ProductWithBrandResult> getProducts(Long brandId, Pageable pageable) {
-        Page<ProductResult> products = productService.getProducts(brandId, pageable);
+        Page<ProductWithLikeCountResult> products = (brandId != null)
+                ? productService.getProductsWithLikeCount(brandId, pageable)
+                : productService.getProductsWithLikeCount(pageable);
 
         return products.map(product -> {
             BrandResult brand = brandService.getBrand(product.brandId());
@@ -61,4 +64,4 @@ public void deleteProduct(Long productId) {
         likeService.deleteLikes(productId);
         productService.deleteProduct(productId);
     }
-}
+}

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

@@ -3,24 +3,27 @@
 import com.loopers.application.product.command.ProductCreateCommand;
 import com.loopers.application.product.command.ProductUpdateCommand;
 import com.loopers.application.product.result.ProductResult;
+import com.loopers.application.product.result.ProductWithLikeCountResult;
 import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductCacheRepository;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.ProductWithLikeCount;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-
-import java.util.List;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
 
 @RequiredArgsConstructor
 @Service
 public class ProductService {
 
     private final ProductRepository productRepository;
+    private final ProductCacheRepository productCacheRepository;
 
     @Transactional
     public ProductResult registerProduct(Long brandId, ProductCreateCommand command) {
@@ -31,27 +34,66 @@ public ProductResult registerProduct(Long brandId, ProductCreateCommand command)
                 .stock(command.stock())
                 .build();
 
-        return ProductResult.from(productRepository.save(product));
+        Product saved = productRepository.save(product);
+        productCacheRepository.evictAllProductsCache();
+        return ProductResult.from(saved);
     }
 
     @Transactional(readOnly = true)
     public ProductResult getProduct(Long productId) {
-        Product product = productRepository.findByIdAndDeletedAtIsNull(productId)
-                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
-
+        Product product = productCacheRepository.getProduct(productId)
+                .orElseGet(() -> {
+                    Product origin = productRepository.findByIdAndDeletedAtIsNull(productId)
+                            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
+                    productCacheRepository.putProduct(productId, origin);
+                    return origin;
+                });
         return ProductResult.from(product);
     }
 
+    @Transactional(readOnly = true)
+    public ProductWithLikeCountResult getProductWithLikeCount(Long productId) {
+        ProductWithLikeCount productWithLikeCount = productCacheRepository.getProductWithLikeCount(productId)
+                .orElseGet(() -> {
+                    ProductWithLikeCount origin = productRepository.findWithLikeCountByIdAndDeletedAtIsNull(productId)
+                            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
+                    productCacheRepository.putProductWithLikeCount(productId, origin);
+                    return origin;
+                });
+        return ProductWithLikeCountResult.from(productWithLikeCount);
+    }
+
     @Transactional(readOnly = true)
     public Page<ProductResult> getProducts(Pageable pageable) {
-        return productRepository.findAllByDeletedAtIsNull(pageable)
-                .map(ProductResult::from);
+        Page<Product> pages = productCacheRepository.getProducts(pageable)
+                .orElseGet(() -> {
+                    Page<Product> origin = productRepository.findAllByDeletedAtIsNull(pageable);
+                    productCacheRepository.putProducts(pageable, origin);
+                    return origin;
+                });
+        return pages.map(ProductResult::from);
+    }
+
+    @Transactional(readOnly = true)
+    public Page<ProductWithLikeCountResult> getProductsWithLikeCount(Pageable pageable) {
+        Page<ProductWithLikeCount> pages = productCacheRepository.getProductsWithLikeCount(pageable)
+                .orElseGet(() -> {
+                    Page<ProductWithLikeCount> origin = productRepository.findAllWithLikeCountByDeletedAtIsNull(pageable);
+                    productCacheRepository.putProductsWithLikeCount(pageable, origin);
+                    return origin;
+                });
+        return pages.map(ProductWithLikeCountResult::from);
     }
 
     @Transactional(readOnly = true)
-    public Page<ProductResult> getProducts(Long brandId, Pageable pageable) {
-        return productRepository.findAllByBrandIdAndDeletedAtIsNull(brandId, pageable)
-                .map(ProductResult::from);
+    public Page<ProductWithLikeCountResult> getProductsWithLikeCount(Long brandId, Pageable pageable) {
+        Page<ProductWithLikeCount> pages = productCacheRepository.getProductsWithLikeCount(brandId, pageable)
+                .orElseGet(() -> {
+                    Page<ProductWithLikeCount> origin = productRepository.findAllWithLikeCountByBrandIdAndDeletedAtIsNull(brandId, pageable);
+                    productCacheRepository.putProductsWithLikeCount(brandId, pageable, origin);
+                    return origin;
+                });
+        return pages.map(ProductWithLikeCountResult::from);
     }
 
     @Transactional(readOnly = true)
@@ -67,6 +109,8 @@ public ProductResult modifyProduct(Long productId, Long brandId, ProductUpdateCo
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
 
         product.changeInfo(brandId, command.name(), command.price(), command.stock());
+        productCacheRepository.evictProduct(productId);
+        productCacheRepository.evictAllProductsCache();
 
         return ProductResult.from(product);
     }
@@ -76,6 +120,8 @@ public ProductResult deductStock(Long productId, int quantity) {
         Product product = productRepository.findByIdWithLockAndDeletedAtIsNull(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
         product.deductStock(quantity);
+        productCacheRepository.evictProduct(productId);
+        productCacheRepository.evictAllProductsCache();
         return ProductResult.from(product);
     }
 
@@ -84,36 +130,26 @@ public void restoreStock(Long productId, int quantity) {
         Product product = productRepository.findByIdWithLockAndDeletedAtIsNull(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
         product.restoreStock(quantity);
-    }
-
-    @Transactional
-    public void incrementLikeCount(Long productId) {
-        int updatedCount = productRepository.incrementLikeCount(productId);
-        if (updatedCount == 0) {
-            throw new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다.");
-        }
-    }
-
-    @Transactional
-    public void decrementLikeCount(Long productId) {
-        int updatedCount = productRepository.decrementLikeCount(productId);
-        if (updatedCount == 0) {
-            throw new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다.");
-        }
+        productCacheRepository.evictProduct(productId);
+        productCacheRepository.evictAllProductsCache();
     }
 
     @Transactional
     public void deleteProduct(Long productId) {
         Product product = productRepository.findById(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
-
         product.delete();
+        productCacheRepository.evictProduct(productId);
+        productCacheRepository.evictAllProductsCache();
     }
 
     @Transactional
     public void deleteProducts(Long brandId) {
         List<Product> products = productRepository.findAllByBrandId(brandId);
-        products.forEach(Product::delete);
+        products.forEach(product -> {
+            product.delete();
+            productCacheRepository.evictProduct(product.getId());
+        });
+        productCacheRepository.evictAllProductsCache();
     }
-
-}
+}

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

@@ -10,7 +10,6 @@ public record ProductResult(
         String name,
         int price,
         int stock,
-        int likeCount,
         ZonedDateTime createdAt,
         ZonedDateTime updatedAt
 ) {
@@ -21,9 +20,8 @@ public static ProductResult from(Product product) {
                 product.getName(),
                 product.getPrice(),
                 product.getStock(),
-                product.getLikeCount(),
                 product.getCreatedAt(),
                 product.getUpdatedAt()
         );
     }
-}
+}

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

@@ -13,7 +13,7 @@ public record ProductWithBrandResult(
         ZonedDateTime createdAt,
         ZonedDateTime updatedAt
 ) {
-    public static ProductWithBrandResult from(ProductResult product, String brandName) {
+    public static ProductWithBrandResult from(ProductWithLikeCountResult product, String brandName) {
         return new ProductWithBrandResult(
                 product.id(),
                 product.brandId(),
@@ -26,4 +26,4 @@ public static ProductWithBrandResult from(ProductResult product, String brandNam
                 product.updatedAt()
         );
     }
-}
+}

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

@@ -0,0 +1,29 @@
+package com.loopers.application.product.result;
+
+import com.loopers.domain.product.ProductWithLikeCount;
+
+import java.time.ZonedDateTime;
+
+public record ProductWithLikeCountResult(
+        Long id,
+        Long brandId,
+        String name,
+        int price,
+        int stock,
+        int likeCount,
+        ZonedDateTime createdAt,
+        ZonedDateTime updatedAt
+) {
+    public static ProductWithLikeCountResult from(ProductWithLikeCount product) {
+        return new ProductWithLikeCountResult(
+                product.id(),
+                product.brandId(),
+                product.name(),
+                product.price(),
+                product.stock(),
+                product.likeCount(),
+                product.createdAt(),
+                product.updatedAt()
+        );
+    }
+}