[volume-5] 인덱스 추가 및 캐시 도입 - 김선민

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

@@ -11,13 +11,16 @@
 @Component
 public class ProductAssembler {
 
-    public List<ProductInfo> toInfos(List<Product> products, List<Brand> brands) {
+    public Map<Long, ProductInfo> toInfoMap(List<Product> products, List<Brand> brands) {
         Map<Long, Brand> brandMap = brands.stream().collect(Collectors.toMap(Brand::getId, b -> b));
 
         return products.stream()
-                .map(product -> {
-                    Brand brand = brandMap.get(product.brandId());
-                    return ProductInfo.of(product, brand != null ? brand.name() : null);
-                }).toList();
+                .collect(Collectors.toMap(
+                        Product::getId,
+                        product -> {
+                            Brand brand = brandMap.get(product.brandId());
+                            return ProductInfo.of(product, brand != null ? brand.name() : null);
+                        }
+                ));
     }
 }

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

@@ -0,0 +1,25 @@
+package com.loopers.application.product;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public interface ProductCacheStore {
+
+    long DETAIL_TTL_MINUTES = 5;
+    long LIST_TTL_SECONDS = 30;
+
+    Optional<ProductInfo> get(Long productId);
+
+    void put(Long productId, ProductInfo productInfo);
+
+    void evict(Long productId);
+
+    record ProductListCacheEntry(List<Long> productIds, int totalPages) {}
+
+    Optional<ProductListCacheEntry> getList(Long brandId, String sort, int page, int size);
+
+    void putList(Long brandId, String sort, int page, int size, List<Long> productIds, int totalPages);
+
+    Map<Long, ProductInfo> multiGet(List<Long> productIds);
+}

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

@@ -5,20 +5,19 @@
 import com.loopers.domain.like.LikeRepository;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
-import com.loopers.domain.product.ProductSortType;
 import com.loopers.domain.product.vo.Price;
 import com.loopers.domain.product.vo.Stock;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import com.loopers.support.page.PageResponse;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.Optional;
+import java.util.Map;
+import java.util.Objects;
 
 @RequiredArgsConstructor
 @Component
@@ -28,6 +27,7 @@ public class ProductFacade {
     private final ProductRepository productRepository;
     private final LikeRepository likeRepository;
     private final ProductAssembler productAssembler;
+    private final ProductQueryService productQueryService;
 
     @Transactional
     public void register(String name, String description, Integer stock, Integer price, Long brandId) {
@@ -49,6 +49,8 @@ public void update(Long productId, String name, String description, Integer stoc
         Stock stockVo = Stock.from(stock);
         Price priceVo = Price.from(price);
         product.update(name, description, stockVo, priceVo);
+
+        productQueryService.evict(productId);
     }
 
     @Transactional(readOnly = true)
@@ -60,42 +62,25 @@ public PageResponse<ProductInfo> getList(Pageable pageable) {
         List<Long> brandIds = productList.stream().map(Product::brandId).toList();
         List<Brand> brands = brandRepository.findAllByIdIn(brandIds);
 
-        List<ProductInfo> productInfos = productAssembler.toInfos(productList, brands);
+        Map<Long, ProductInfo> infoMap = productAssembler.toInfoMap(productList, brands);
+        List<ProductInfo> productInfos = productList.stream().map(p -> infoMap.get(p.getId())).filter(Objects::nonNull).toList();
         return new PageResponse<>(productInfos, products.page(), products.size(), products.totalPages());
     }
 
     @Transactional(readOnly = true)
     public PageResponse<ProductInfo> getList(Pageable pageable, Long brandId, String sort) {
-        PageRequest pageRequest = PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), ProductSortType.from(sort).getSort());
-        PageResponse<Product> products;
-        if (brandId == null) {
-            products = productRepository.findAll(pageRequest);
-        } else {
-            products = productRepository.findAllByBrandId(brandId, pageRequest);
-        }
-
-        List<Product> productList = products.content();
-        if (productList.isEmpty()) return new PageResponse<>(List.of(), products.page(), products.size(), products.totalPages());
-
-        List<Long> brandIds = productList.stream().map(Product::brandId).toList();
-        List<Brand> brands = brandRepository.findAllByIdIn(brandIds);
-
-        List<ProductInfo> productInfos = productAssembler.toInfos(productList, brands);
-        return new PageResponse<>(productInfos, products.page(), products.size(), products.totalPages());
+        return productQueryService.getList(pageable, brandId, sort);
     }
 
     @Transactional(readOnly = true)
     public ProductInfo getDetail(Long productId) {
-        Product product = productRepository.findById(productId)
-                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다."));
-
-        Optional<Brand> optionalBrand = brandRepository.findById(product.brandId());
-        return ProductInfo.of(product, optionalBrand.map(Brand::name).orElse(null));
+        return productQueryService.getDetail(productId);
     }
 
     @Transactional
     public void delete(Long productId) {
         likeRepository.deleteAllByProductId(productId);
         productRepository.deleteById(productId);
+        productQueryService.evict(productId);
     }
 }

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

@@ -0,0 +1,116 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.brand.BrandRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.ProductSortType;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.support.page.PageResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class ProductQueryService {
+
+    private final ProductRepository productRepository;
+    private final BrandRepository brandRepository;
+    private final ProductAssembler productAssembler;
+    private final ProductCacheStore productCacheStore;
+
+    @Transactional(readOnly = true)
+    public PageResponse<ProductInfo> getList(Pageable pageable, Long brandId, String sort) {
+        int page = pageable.getPageNumber();
+        int size = pageable.getPageSize();
+        PageRequest pageRequest = PageRequest.of(page, size, ProductSortType.from(sort).getSort());
+
+        return productCacheStore.getList(brandId, sort, page, size)
+                .map(entry -> resolveFromCache(entry, page, size))
+                .orElseGet(() -> resolveFromDatabase(brandId, pageRequest, sort, page, size));
+    }
+
+    private PageResponse<ProductInfo> resolveFromCache(ProductCacheStore.ProductListCacheEntry entry, int page, int size) {
+        List<Long> productIds = entry.productIds();
+        int totalPages = entry.totalPages();
+        if (productIds.isEmpty()) {
+            return new PageResponse<>(List.of(), page, size, totalPages);
+        }
+
+        Map<Long, ProductInfo> cachedInfos = productCacheStore.multiGet(productIds);
+        List<Long> missingIds = productIds.stream().filter(id -> !cachedInfos.containsKey(id)).toList();
+        if (missingIds.isEmpty()) {
+            return new PageResponse<>(productIds.stream().map(cachedInfos::get).toList(), page, size, totalPages);
+        }
+
+        Map<Long, ProductInfo> allInfoMap = new HashMap<>(cachedInfos);
+        List<Product> missingProducts = productRepository.findAllByIdIn(missingIds);
+        List<Long> missingBrandIds = missingProducts.stream().map(Product::brandId).distinct().toList();
+        List<Brand> missingBrands = brandRepository.findAllByIdIn(missingBrandIds);
+        Map<Long, ProductInfo> missingInfoMap = productAssembler.toInfoMap(missingProducts, missingBrands);
+        allInfoMap.putAll(missingInfoMap);
+        missingInfoMap.forEach(productCacheStore::put);
+
+        List<ProductInfo> orderedInfos = productIds.stream()
+                .map(allInfoMap::get)
+                .filter(Objects::nonNull)
+                .toList();
+
+        return new PageResponse<>(orderedInfos, page, size, totalPages);
+    }
+
+    private PageResponse<ProductInfo> resolveFromDatabase(Long brandId, PageRequest pageRequest, String sort, int page, int size) {
+        PageResponse<Product> products = brandId == null
+                ? productRepository.findAll(pageRequest)
+                : productRepository.findAllByBrandId(brandId, pageRequest);
+
+        List<Product> productList = products.content();
+        if (productList.isEmpty()) {
+            productCacheStore.putList(brandId, sort, page, size, List.of(), products.totalPages());
+            return new PageResponse<>(List.of(), products.page(), products.size(), products.totalPages());
+        }
+
+        List<Long> brandIds = productList.stream().map(Product::brandId).toList();
+        List<Brand> brands = brandRepository.findAllByIdIn(brandIds);
+        Map<Long, ProductInfo> infoMap = productAssembler.toInfoMap(productList, brands);
+
+        List<Long> productIds = productList.stream().map(Product::getId).toList();
+        productCacheStore.putList(brandId, sort, page, size, productIds, products.totalPages());
+        infoMap.forEach((id, info) -> productCacheStore.put(id, info));
+
+        List<ProductInfo> orderedInfos = productIds.stream().map(infoMap::get).filter(Objects::nonNull).toList();
+        return new PageResponse<>(orderedInfos, products.page(), products.size(), products.totalPages());
+    }
+
+    @Transactional(readOnly = true)
+    public ProductInfo getDetail(Long productId) {
+        Optional<ProductInfo> cached = productCacheStore.get(productId);
+        if (cached.isPresent()) {
+            return cached.get();
+        }
+
+        Product product = productRepository.findById(productId)
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다."));
+
+        Optional<Brand> optionalBrand = brandRepository.findById(product.brandId());
+        ProductInfo productInfo = ProductInfo.of(product, optionalBrand.map(Brand::name).orElse(null));
+
+        productCacheStore.put(productId, productInfo);
+
+        return productInfo;
+    }
+
+    public void evict(Long productId) {
+        productCacheStore.evict(productId);
+    }
+}

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

@@ -6,7 +6,8 @@
 
 public enum ProductSortType {
     LATEST(Sort.by(Sort.Direction.DESC, "createdAt")), // 또는 "createdAt"
-    PRICE_ASC(Sort.by(Sort.Direction.ASC, "price"));
+    PRICE_ASC(Sort.by(Sort.Direction.ASC, "price")),
+    LIKE_COUNT(Sort.by(Sort.Direction.DESC, "likeCount"));
 
     private final Sort sort;
 

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

@@ -0,0 +1,96 @@
+package com.loopers.infrastructure.product;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.application.product.ProductCacheStore;
+import com.loopers.application.product.ProductInfo;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+
+@RequiredArgsConstructor
+@Component
+public class RedisProductCacheStore implements ProductCacheStore {
+
+    private static final String DETAIL_KEY_PREFIX = "product:detail:";
+    private static final String LIST_KEY_PREFIX = "product:list:";
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    @Override
+    public Optional<ProductInfo> get(Long productId) {
+        try {
+            String cached = redisTemplate.opsForValue().get(DETAIL_KEY_PREFIX + productId);
+            if (cached != null) {
+                return Optional.of(objectMapper.readValue(cached, ProductInfo.class));
+            }
+        } catch (Exception ignored) {
+        }
+        return Optional.empty();
+    }
+
+    @Override
+    public void put(Long productId, ProductInfo productInfo) {
+        try {
+            String json = objectMapper.writeValueAsString(productInfo);
+            redisTemplate.opsForValue().set(DETAIL_KEY_PREFIX + productId, json, DETAIL_TTL_MINUTES, TimeUnit.MINUTES);
+        } catch (Exception ignored) {
+        }
+    }
+
+    @Override
+    public void evict(Long productId) {
+        redisTemplate.delete(DETAIL_KEY_PREFIX + productId);
+    }
+
+    @Override
+    public Optional<ProductListCacheEntry> getList(Long brandId, String sort, int page, int size) {
+        try {
+            String cached = redisTemplate.opsForValue().get(listKey(brandId, sort, page, size));
+            if (cached != null) {
+                return Optional.of(objectMapper.readValue(cached, ProductListCacheEntry.class));
+            }
+        } catch (Exception ignored) {
+        }
+        return Optional.empty();
+    }
+
+    @Override
+    public void putList(Long brandId, String sort, int page, int size, List<Long> productIds, int totalPages) {
+        try {
+            String json = objectMapper.writeValueAsString(new ProductListCacheEntry(productIds, totalPages));
+            redisTemplate.opsForValue().set(listKey(brandId, sort, page, size), json, LIST_TTL_SECONDS, TimeUnit.SECONDS);
+        } catch (Exception ignored) {
+        }
+    }
+
+    @Override
+    public Map<Long, ProductInfo> multiGet(List<Long> productIds) {
+        List<String> keys = productIds.stream()
+                .map(id -> DETAIL_KEY_PREFIX + id)
+                .toList();
+        List<String> values = redisTemplate.opsForValue().multiGet(keys);
+        Map<Long, ProductInfo> result = new HashMap<>();
+        if (values == null) return result;
+        for (int i = 0; i < productIds.size(); i++) {
+            String value = values.get(i);
+            if (value != null) {
+                try {
+                    result.put(productIds.get(i), objectMapper.readValue(value, ProductInfo.class));
+                } catch (Exception ignored) {
+                }
+            }
+        }
+        return result;
+    }
+
+    private String listKey(Long brandId, String sort, int page, int size) {
+        return LIST_KEY_PREFIX + "brandId=" + brandId + ":sort=" + sort + ":page=" + page + ":size=" + size;
+    }
+}