[volume-5] 상품 목록 조회 성능, 좋아요 수 정렬 구조 개선 및 인덱스,캐시 적용

.gitignore

@@ -45,6 +45,9 @@ claude/*
 .claude/settings.local.json
 .interview-state/
 
+### Static Resources ###
+**/src/main/resources/static/
+
 ### Documentation ###
 docs/*
 !docs/design/

apps/commerce-api/src/main/java/com/loopers/application/brand/BrandFacade.java

@@ -5,7 +5,11 @@
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.product.ProductService;
+import com.loopers.support.cache.CacheType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
@@ -18,6 +22,7 @@ public class BrandFacade {
     private final BrandService brandService;
     private final ProductService productService;
 
+    @CacheEvict(cacheNames = CacheType.Names.BRAND_LIST, allEntries = true)
     @Transactional
     public void registerBrand(BrandCriteria.Register criteria) {
         brandService.register(criteria.name());
@@ -29,19 +34,31 @@ public BrandResult getBrand(Long id) {
         return BrandResult.from(brandModel);
     }
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheType.Names.BRAND_LIST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES, allEntries = true)})
     @Transactional
     public void updateBrand(Long id, BrandCriteria.Update criteria) {
         brandService.update(id, criteria.name());
     }
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheType.Names.BRAND_LIST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES, allEntries = true)})
     @Transactional
     public void deleteBrand(Long id) {
         brandService.delete(id);
         productService.deleteAllByBrandId(id);
     }
 
+    @Cacheable(cacheNames = CacheType.Names.BRAND_LIST, key = "'all'")
     @Transactional(readOnly = true)
-    public Page<BrandResult> getBrands(Pageable pageable) {
-        return brandService.getAll(pageable).map(BrandResult::from);
+    public BrandResult.ListPage getBrands(Pageable pageable) {
+        return BrandResult.ListPage.from(
+                brandService.getAll(pageable).map(BrandResult::from));
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/brand/dto/BrandResult.java

@@ -2,9 +2,26 @@
 
 import com.loopers.domain.brand.BrandModel;
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import org.springframework.data.domain.Page;
 
 public record BrandResult(Long id, String name, ZonedDateTime createdAt, ZonedDateTime updatedAt, ZonedDateTime deletedAt) {
     public static BrandResult from(BrandModel model) {
         return new BrandResult(model.getId(), model.getName(), model.getCreatedAt(), model.getUpdatedAt(), model.getDeletedAt());
     }
+
+    public record ListPage(
+            int page, int size, long totalElements, int totalPages,
+            List<BrandResult> items
+    ) {
+        public static ListPage from(Page<BrandResult> resultPage) {
+            return new ListPage(
+                    resultPage.getNumber(),
+                    resultPage.getSize(),
+                    resultPage.getTotalElements(),
+                    resultPage.getTotalPages(),
+                    new ArrayList<>(resultPage.getContent()));
+        }
+    }
 }

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

@@ -3,17 +3,21 @@
 import com.loopers.application.product.dto.ProductCriteria;
 import com.loopers.application.product.dto.ProductResult;
 import com.loopers.domain.brand.BrandService;
-import com.loopers.domain.product.ProductLikeService;
+import com.loopers.domain.product.ImageType;
+import com.loopers.domain.product.ProductImageService;
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
-import com.loopers.support.util.PaginationUtils;
-import java.util.Comparator;
-import java.util.List;
+import com.loopers.support.cache.CacheType;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -23,8 +27,12 @@ public class ProductFacade {
 
     private final ProductService productService;
     private final BrandService brandService;
-    private final ProductLikeService productLikeService;
+    private final ProductImageService productImageService;
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES, allEntries = true)})
     @Transactional
     public void registerProduct(ProductCriteria.Register criteria) {
         brandService.validateExists(criteria.brandId());
@@ -36,15 +44,37 @@ public ProductResult getProduct(Long id) {
         ProductModel product = productService.getById(id);
         return ProductResult.of(
                 product,
-                brandService.getById(product.getBrandId()).getName(),
-                productLikeService.countLikes(id));
+                brandService.getById(product.getBrandId()).getName());
     }
 
+    @Transactional(readOnly = true)
+    public ProductResult.DetailWithImages getProductDetail(Long id) {
+        ProductModel product = productService.getById(id);
+        return new ProductResult.DetailWithImages(
+                ProductResult.of(
+                        product,
+                        brandService.getById(product.getBrandId()).getName()),
+                productImageService.getImagesByProductIdAndType(id, ImageType.MAIN).stream()
+                        .map(ProductResult.ImageResult::from)
+                        .toList(),
+                productImageService.getImagesByProductIdAndType(id, ImageType.DETAIL).stream()
+                        .map(ProductResult.ImageResult::from)
+                        .toList());
+    }
+
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES, allEntries = true)})
     @Transactional
     public void updateProduct(Long id, ProductCriteria.Update criteria) {
         productService.update(id, criteria.name(), criteria.price(), criteria.stock());
     }
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE, allEntries = true),
+            @CacheEvict(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES, allEntries = true)})
     @Transactional
     public void deleteProduct(Long id) {
         productService.delete(id);
@@ -69,7 +99,10 @@ public Page<ProductResult> getProductsByBrandId(Long brandId, Pageable pageable)
     public Page<ProductResult> getProductsWithActiveBrand(Pageable pageable) {
         Page<ProductModel> products = productService.getAll(pageable);
         return new PageImpl<>(
-                toResultsWithActiveBrand(products.getContent()),
+                ProductResult.fromWithActiveBrand(
+                        products.getContent(),
+                        brandService.getActiveNameMapByIds(
+                                ProductModel.extractDistinctBrandIds(products.getContent()))),
                 products.getPageable(),
                 products.getTotalElements());
     }
@@ -78,34 +111,70 @@ public Page<ProductResult> getProductsWithActiveBrand(Pageable pageable) {
     public Page<ProductResult> getProductsWithActiveBrandByBrandId(Long brandId, Pageable pageable) {
         Page<ProductModel> products = productService.getAllByBrandId(brandId, pageable);
         return new PageImpl<>(
-                toResultsWithActiveBrand(products.getContent()),
+                ProductResult.fromWithActiveBrand(
+                        products.getContent(),
+                        brandService.getActiveNameMapByIds(
+                                ProductModel.extractDistinctBrandIds(products.getContent()))),
                 products.getPageable(),
                 products.getTotalElements());
     }
 
     @Transactional(readOnly = true)
     public Page<ProductResult> getProductsWithActiveBrandSortedByLikes(int page, int size) {
-        return toPageSortedByLikes(productService.getAll(), page, size);
+        Page<ProductModel> products = productService.getAllSortedByLikeCountDesc(
+                PageRequest.of(page, size));
+        return new PageImpl<>(
+                ProductResult.fromWithActiveBrand(
+                        products.getContent(),
+                        brandService.getActiveNameMapByIds(
+                                ProductModel.extractDistinctBrandIds(products.getContent()))),
+                products.getPageable(),
+                products.getTotalElements());
     }
 
     @Transactional(readOnly = true)
-    public Page<ProductResult> getProductsWithActiveBrandByBrandIdSortedByLikes(Long brandId, int page, int size) {
-        return toPageSortedByLikes(productService.getAllByBrandId(brandId), page, size);
+    public Page<ProductResult> getProductsWithActiveBrandByBrandIdSortedByLikes(
+            Long brandId, int page, int size) {
+        Page<ProductModel> products = productService.getAllByBrandIdSortedByLikeCountDesc(
+                brandId, PageRequest.of(page, size));
+        return new PageImpl<>(
+                ProductResult.fromWithActiveBrand(
+                        products.getContent(),
+                        brandService.getActiveNameMapByIds(
+                                ProductModel.extractDistinctBrandIds(products.getContent()))),
+                products.getPageable(),
+                products.getTotalElements());
     }
 
-    private Page<ProductResult> toPageSortedByLikes(List<ProductModel> products, int page, int size) {
-        List<ProductResult> sorted = toResultsWithActiveBrand(products).stream()
-                .sorted(Comparator.comparingLong(ProductResult::likeCount).reversed())
-                .toList();
-        return PaginationUtils.toPage(sorted, page, size);
+    @Cacheable(cacheNames = CacheType.Names.PRODUCT_LIST_LATEST,
+            key = "(#brandId ?: 'all') + ':' + #page + ':' + #size")
+    @Transactional(readOnly = true)
+    public ProductResult.ListPage getProductListLatest(Long brandId, int page, int size) {
+        Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"));
+        return ProductResult.ListPage.from(brandId != null
+                ? getProductsWithActiveBrandByBrandId(brandId, pageable)
+                : getProductsWithActiveBrand(pageable));
     }
 
-    private List<ProductResult> toResultsWithActiveBrand(List<ProductModel> products) {
-        return ProductResult.fromWithActiveBrand(
-                products,
-                brandService.getActiveNameMapByIds(
-                        ProductModel.extractDistinctBrandIds(products)),
-                productLikeService.countLikesByProductIds(
-                        ProductModel.extractIds(products)));
+    @Cacheable(cacheNames = CacheType.Names.PRODUCT_LIST_PRICE,
+            key = "#sort + ':' + (#brandId ?: 'all') + ':' + #page + ':' + #size")
+    @Transactional(readOnly = true)
+    public ProductResult.ListPage getProductListByPrice(
+            Long brandId, String sort, int page, int size) {
+        Sort sortOrder = "price_asc".equals(sort)
+                ? Sort.by(Sort.Direction.ASC, "price")
+                : Sort.by(Sort.Direction.DESC, "price");
+        return ProductResult.ListPage.from(brandId != null
+                ? getProductsWithActiveBrandByBrandId(brandId, PageRequest.of(page, size, sortOrder))
+                : getProductsWithActiveBrand(PageRequest.of(page, size, sortOrder)));
+    }
+
+    @Cacheable(cacheNames = CacheType.Names.PRODUCT_LIST_LIKES,
+            key = "(#brandId ?: 'all') + ':' + #page + ':' + #size")
+    @Transactional(readOnly = true)
+    public ProductResult.ListPage getProductListByLikes(Long brandId, int page, int size) {
+        return ProductResult.ListPage.from(brandId != null
+                ? getProductsWithActiveBrandByBrandIdSortedByLikes(brandId, page, size)
+                : getProductsWithActiveBrandSortedByLikes(page, size));
     }
 }

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

@@ -18,11 +18,13 @@ public class ProductLikeFacade {
     public void like(Long userId, Long productId) {
         productService.validateExists(productId);
         productLikeService.like(userId, productId);
+        productService.incrementLikeCount(productId);
     }
 
     @Transactional
     public void unlike(Long userId, Long productId) {
         productLikeService.unlike(userId, productId);
+        productService.decrementLikeCount(productId);
     }
 
     @Transactional(readOnly = true)

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

@@ -1,9 +1,13 @@
 package com.loopers.application.product.dto;
 
+import com.loopers.domain.product.ImageType;
+import com.loopers.domain.product.ProductImageModel;
 import com.loopers.domain.product.ProductModel;
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import org.springframework.data.domain.Page;
 
 public record ProductResult(
     Long id,
@@ -13,37 +17,60 @@ public record ProductResult(
     int price,
     int stock,
     long likeCount,
+    String thumbnailUrl,
     ZonedDateTime createdAt,
     ZonedDateTime updatedAt,
     ZonedDateTime deletedAt
 ) {
     public static ProductResult of(ProductModel model, String brandName) {
-        return of(model, brandName, 0L);
-    }
-
-    public static ProductResult of(ProductModel model, String brandName, long likeCount) {
         return new ProductResult(
                 model.getId(),
                 model.getBrandId(),
                 brandName,
                 model.getName(),
                 model.getPrice(),
                 model.getStock(),
-                likeCount,
+                model.getLikeCount(),
+                model.getThumbnailUrl(),
                 model.getCreatedAt(),
                 model.getUpdatedAt(),
                 model.getDeletedAt());
     }
 
     public static List<ProductResult> fromWithActiveBrand(
-            List<ProductModel> products, Map<Long, String> brandNameMap,
-            Map<Long, Long> likeCountMap) {
+            List<ProductModel> products, Map<Long, String> brandNameMap) {
         return products.stream()
                 .filter(product -> brandNameMap.containsKey(product.getBrandId()))
                 .map(product -> ProductResult.of(
-                        product,
-                        brandNameMap.get(product.getBrandId()),
-                        likeCountMap.getOrDefault(product.getId(), 0L)))
+                        product, brandNameMap.get(product.getBrandId())))
                 .toList();
     }
+
+    public record ImageResult(Long id, String imageUrl, ImageType imageType, int sortOrder) {
+        public static ImageResult from(ProductImageModel model) {
+            return new ImageResult(
+                    model.getId(), model.getImageUrl(), model.getImageType(), model.getSortOrder());
+        }
+    }
+
+    public record ListPage(
+        int page, int size, long totalElements, int totalPages,
+        List<ProductResult> items
+    ) {
+        public static ListPage from(Page<ProductResult> resultPage) {
+            return new ListPage(
+                    resultPage.getNumber(),
+                    resultPage.getSize(),
+                    resultPage.getTotalElements(),
+                    resultPage.getTotalPages(),
+                    new ArrayList<>(resultPage.getContent()));
+        }
+    }
+
+    public record DetailWithImages(
+        ProductResult product,
+        List<ImageResult> mainImages,
+        List<ImageResult> detailImages
+    ) {
+    }
 }

apps/commerce-api/src/main/java/com/loopers/application/user/dto/UserResult.java

@@ -7,14 +7,16 @@ public record UserResult(
     String loginId,
     String name,
     String birthDate,
-    String email
+    String email,
+    long point
 ) {
     public static UserResult from(UserModel model) {
         return new UserResult(
                 model.getId(),
                 model.getLoginId(),
                 model.getName(),
                 model.getBirthDateString(),
-                model.getEmail());
+                model.getEmail(),
+                model.getPoint());
     }
 }

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

@@ -0,0 +1,6 @@
+package com.loopers.domain.product;
+
+public enum ImageType {
+    MAIN,
+    DETAIL
+}