[volume-9] Product Ranking with Redis

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

@@ -10,6 +10,7 @@
 import com.loopers.domain.supply.Supply;
 import com.loopers.domain.supply.SupplyService;
 import com.loopers.infrastructure.cache.product.ProductCacheService;
+import com.loopers.application.ranking.RankingFacade;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -18,6 +19,8 @@
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -30,6 +33,7 @@ public class ProductFacade {
     private final SupplyService supplyService;
     private final ProductCacheService productCacheService;
     private final ProductViewedEventPublisher productViewedEventPublisher;
+    private final RankingFacade rankingFacade;
 
     @Transactional
     public ProductInfo createProduct(ProductCreateRequest request) {
@@ -268,6 +272,32 @@ public ProductInfo getProductDetail(Long productId) {
         productCacheService.setProductDetail(productId, Optional.of(productInfo));
         return productInfo;
     }
+
+    /**
+     * 상품 상세 조회 (랭킹 정보 포함)
+     * @param productId 상품 ID
+     * @return 상품 정보와 랭킹 정보를 포함한 응답
+     */
+    @Transactional(readOnly = true)
+    public ProductInfoWithRanking getProductDetailWithRanking(Long productId) {
+        ProductInfo productInfo = getProductDetail(productId);
+
+        // 랭킹 정보 조회
+        String today = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+        com.loopers.application.ranking.RankingInfo.ProductRankingInfo rankingInfo = 
+                rankingFacade.getProductRanking(productId, today);
+
+        return new ProductInfoWithRanking(productInfo, rankingInfo);
+    }
+
+    /**
+     * 상품 정보와 랭킹 정보를 포함한 응답
+     */
+    public record ProductInfoWithRanking(
+            ProductInfo productInfo,
+            com.loopers.application.ranking.RankingInfo.ProductRankingInfo rankingInfo
+    ) {
+    }
 
     private void invalidateBrandListCache(Long brandId) {
         try {

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingFacade.java

@@ -0,0 +1,107 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.ranking.RankingService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 랭킹 Facade
+ * <p>
+ * 랭킹 조회 로직을 담당하며, ZSET에서 랭킹 정보를 조회하고
+ * 상품 정보를 Aggregation하여 반환합니다.
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class RankingFacade {
+
+    private final RankingService rankingService;
+    private final ProductService productService;
+
+    /**
+     * 랭킹 페이지 조회
+     * 1. ZSET에서 Top-N 상품 ID 조회
+     * 2. 상품 정보 조회 및 Aggregation
+     * 3. 순위 정보 포함하여 반환
+     */
+    @Transactional(readOnly = true)
+    public RankingInfo.RankingsPageResponse getRankings(String date, Pageable pageable) {
+        String rankingKey = rankingService.getRankingKey(date);
+
+        // 페이지네이션 계산
+        long start = pageable.getPageNumber() * pageable.getPageSize();
+        long end = start + pageable.getPageSize() - 1;
+
+        // ZSET에서 상품 ID와 점수 조회
+        List<RankingService.RankingEntry> entries =
+                rankingService.getTopNWithScores(rankingKey, start, end);
+
+        if (entries.isEmpty()) {
+            return RankingInfo.RankingsPageResponse.empty(pageable);
+        }
+
+        // 상품 ID 리스트 추출
+        List<Long> productIds = entries.stream()
+                .map(RankingService.RankingEntry::getProductId)
+                .collect(Collectors.toList());
+
+        // 상품 정보 조회
+        Map<Long, Product> productMap = productService.getProductMapByIds(productIds);
+
+        // 랭킹 정보와 상품 정보 결합
+        List<RankingInfo.RankingItem> rankingItems = new ArrayList<>();
+        long rank = start + 1; // 1부터 시작하는 순위
+
+        for (RankingService.RankingEntry entry : entries) {
+            Product product = productMap.get(entry.getProductId());
+            if (product != null) {
+                rankingItems.add(RankingInfo.RankingItem.of(
+                        rank++,
+                        entry.getProductId(),
+                        entry.getScore(),
+                        product
+                ));
+            }
+        }
+
+        // 전체 랭킹 수 조회 (총 페이지 수 계산용)
+        Long totalSize = rankingService.getRankingSize(rankingKey);
+
+        return RankingInfo.RankingsPageResponse.of(
+                rankingItems,
+                pageable.getPageNumber(),
+                pageable.getPageSize(),
+                totalSize != null ? totalSize.intValue() : 0
+        );
+    }
+
+    /**
+     * 특정 상품의 랭킹 정보 조회
+     */
+    @Transactional(readOnly = true)
+    public RankingInfo.ProductRankingInfo getProductRanking(Long productId, String date) {
+        String rankingKey = rankingService.getRankingKey(date);
+        Long rank = rankingService.getRank(rankingKey, productId);
+        Double score = rankingService.getScore(rankingKey, productId);
+
+        if (rank == null || score == null) {
+            return null; // 랭킹에 없음
+        }
+
+        return RankingInfo.ProductRankingInfo.of(
+                rank + 1, // 1부터 시작하는 순위로 변환
+                score
+        );
+    }
+}
+

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingInfo.java

@@ -0,0 +1,77 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.product.Product;
+import org.springframework.data.domain.Pageable;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 랭킹 정보 DTO
+ */
+public class RankingInfo {
+
+    /**
+     * 랭킹 페이지 응답
+     */
+    public record RankingsPageResponse(
+            List<RankingItem> items,
+            int page,
+            int size,
+            int total
+    ) {
+        public static RankingsPageResponse empty(Pageable pageable) {
+            return new RankingsPageResponse(
+                    Collections.emptyList(),
+                    pageable.getPageNumber(),
+                    pageable.getPageSize(),
+                    0
+            );
+        }
+
+        public static RankingsPageResponse of(
+                List<RankingItem> items,
+                int page,
+                int size,
+                int total
+        ) {
+            return new RankingsPageResponse(items, page, size, total);
+        }
+    }
+
+    /**
+     * 랭킹 항목 (상품 정보 + 순위 + 점수)
+     */
+    public record RankingItem(
+            Long rank,
+            Long productId,
+            Double score,
+            String productName,
+            Long brandId,
+            Integer price
+    ) {
+        public static RankingItem of(Long rank, Long productId, Double score, Product product) {
+            return new RankingItem(
+                    rank,
+                    productId,
+                    score,
+                    product.getName(),
+                    product.getBrandId(),
+                    product.getPrice().amount()
+            );
+        }
+    }
+
+    /**
+     * 상품 랭킹 정보 (상세 조회용)
+     */
+    public record ProductRankingInfo(
+            Long rank,
+            Double score
+    ) {
+        public static ProductRankingInfo of(Long rank, Double score) {
+            return new ProductRankingInfo(rank, score);
+        }
+    }
+}
+

apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java

@@ -79,8 +79,11 @@ private Pageable normalizePageable(Pageable pageable) {
     @RequestMapping(method = RequestMethod.GET, path = "/{productId}")
     @Override
     public ApiResponse<ProductV1Dto.ProductResponse> getProductDetail(@PathVariable Long productId) {
-        ProductInfo info = productFacade.getProductDetail(productId);
-        ProductV1Dto.ProductResponse response = ProductV1Dto.ProductResponse.from(info);
+        ProductFacade.ProductInfoWithRanking infoWithRanking = productFacade.getProductDetailWithRanking(productId);
+        ProductV1Dto.ProductResponse response = ProductV1Dto.ProductResponse.from(
+                infoWithRanking.productInfo(),
+                ProductV1Dto.RankingInfo.from(infoWithRanking.rankingInfo())
+        );
         return ApiResponse.success(response);
     }
 }

apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java

@@ -20,18 +20,39 @@ public record ProductResponse(
             String brand,
             int price,
             int likes,
-            int stock
+            int stock,
+            RankingInfo rankingInfo
     ) {
-        public static ProductResponse from(ProductInfo info) {
+        public static ProductResponse from(ProductInfo info, RankingInfo rankingInfo) {
             return new ProductResponse(
                     info.id(),
                     info.name(),
                     info.brand(),
                     info.price(),
                     info.likes(),
-                    info.stock()
+                    info.stock(),
+                    rankingInfo
             );
         }
+
+        public static ProductResponse from(ProductInfo info) {
+            return from(info, null);
+        }
+    }
+
+    /**
+     * 상품 랭킹 정보
+     */
+    public record RankingInfo(
+            Long rank,
+            Double score
+    ) {
+        public static RankingInfo from(com.loopers.application.ranking.RankingInfo.ProductRankingInfo info) {
+            if (info == null) {
+                return null;
+            }
+            return new RankingInfo(info.rank(), info.score());
+        }
     }
 
     public record ProductsPageResponse(

apps/commerce-api/src/main/java/com/loopers/interfaces/api/ranking/RankingV1ApiSpec.java

@@ -0,0 +1,29 @@
+package com.loopers.interfaces.api.ranking;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "Ranking V1 API", description = "랭킹 API 입니다.")
+public interface RankingV1ApiSpec {
+
+    @Operation(
+            method = "GET",
+            summary = "랭킹 페이지 조회",
+            description = "일간 랭킹을 페이지네이션으로 조회합니다."
+    )
+    ApiResponse<RankingV1Dto.RankingsPageResponse> getRankings(
+            @Parameter(description = "날짜 (yyyyMMdd 형식, 미지정 시 오늘 날짜)", example = "20241219")
+            @Schema(description = "날짜 (yyyyMMdd 형식, 미지정 시 오늘 날짜)", example = "20241219")
+            String date,
+            @Parameter(description = "페이지 크기", example = "20")
+            @Schema(description = "페이지 크기", example = "20")
+            int size,
+            @Parameter(description = "페이지 번호 (0부터 시작)", example = "0")
+            @Schema(description = "페이지 번호 (0부터 시작)", example = "0")
+            int page
+    );
+}
+

apps/commerce-api/src/main/java/com/loopers/interfaces/api/ranking/RankingV1Controller.java

@@ -0,0 +1,41 @@
+package com.loopers.interfaces.api.ranking;
+
+import com.loopers.application.ranking.RankingFacade;
+import com.loopers.application.ranking.RankingInfo;
+import com.loopers.interfaces.api.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/rankings")
+public class RankingV1Controller implements RankingV1ApiSpec {
+
+    private final RankingFacade rankingFacade;
+
+    @GetMapping
+    @Override
+    public ApiResponse<RankingV1Dto.RankingsPageResponse> getRankings(
+            @RequestParam(required = false) String date,
+            @RequestParam(defaultValue = "20") int size,
+            @RequestParam(defaultValue = "0") int page
+    ) {
+        String rankingDate = date != null ? date :
+                LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+
+        Pageable pageable = PageRequest.of(page, size);
+        RankingInfo.RankingsPageResponse response =
+                rankingFacade.getRankings(rankingDate, pageable);
+
+        return ApiResponse.success(RankingV1Dto.RankingsPageResponse.from(response));
+    }
+}
+