[volume-9] Product Ranking with Redis

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

@@ -11,7 +11,8 @@ public record ProductDetailInfo(
         Integer stock,
         Long brandId,
         String brandName,
-        Long likeCount
+        Long likeCount,
+        Long rank
 ) implements Serializable {
     public static ProductDetailInfo of(Product product, Long likeCount) {
         return new ProductDetailInfo(
@@ -21,7 +22,34 @@ public static ProductDetailInfo of(Product product, Long likeCount) {
                 product.getStockValue(),
                 product.getBrand().getId(),
                 product.getBrand().getName(),
-                likeCount
+                likeCount,
+                null
+        );
+    }
+
+    public static ProductDetailInfo of(Product product, Long likeCount, Long rank) {
+        return new ProductDetailInfo(
+                product.getId(),
+                product.getName(),
+                product.getPriceValue(),
+                product.getStockValue(),
+                product.getBrand().getId(),
+                product.getBrand().getName(),
+                likeCount,
+                rank
+        );
+    }
+
+    public ProductDetailInfo withRank(Long rank) {
+        return new ProductDetailInfo(
+                this.productId,
+                this.productName,
+                this.price,
+                this.stock,
+                this.brandId,
+                this.brandName,
+                this.likeCount,
+                rank
         );
     }
 }

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

@@ -1,5 +1,6 @@
 package com.loopers.application.product;
 
+import com.loopers.application.ranking.RankingFacade;
 import com.loopers.domain.product.ProductSearchCondition;
 import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserActionEvent;
@@ -18,11 +19,15 @@ public class ProductFacade {
     private final ProductCacheService productCacheService;
     private final UserService userService;
     private final ApplicationEventPublisher eventPublisher;
+    private final RankingFacade rankingFacade;
 
     @Transactional(readOnly = true)
     public ProductDetailInfo getProductDetail(Long productId, String loginId) {
         ProductDetailInfo productDetail = productCacheService.getProductDetailWithCache(productId);
 
+        Long rank = rankingFacade.getProductRankToday(productId);
+        productDetail = productDetail.withRank(rank);
+
         // 유저 행동 로깅
         if (loginId != null) {
             try {
@@ -40,7 +45,11 @@ public ProductDetailInfo getProductDetail(Long productId, String loginId) {
 
     @Transactional(readOnly = true)
     public ProductDetailInfo getProductDetail(Long productId) {
-        return productCacheService.getProductDetailWithCache(productId);
+        ProductDetailInfo productDetail = productCacheService.getProductDetailWithCache(productId);
+
+        // 랭킹 정보 추가
+        Long rank = rankingFacade.getProductRankToday(productId);
+        return productDetail.withRank(rank);
     }
 
     public ProductListInfo getProducts(ProductGetListCommand command) {

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

@@ -0,0 +1,49 @@
+package com.loopers.application.ranking;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+public record RankingCommand(
+        LocalDate date,
+        int page,
+        int size
+) {
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private static final int MAX_PAGE_SIZE = 100;
+    private static final int DEFAULT_PAGE_SIZE = 20;
+
+    public RankingCommand {
+        // 유효성 검증
+        if (page < 0) {
+            page = 0;
+        }
+        if (size <= 0 || size > MAX_PAGE_SIZE) {
+            size = DEFAULT_PAGE_SIZE;
+        }
+        if (date == null) {
+            date = LocalDate.now();
+        }
+    }
+
+    public static RankingCommand of(String dateString, int page, int size) {
+        LocalDate date = parseDate(dateString);
+        return new RankingCommand(date, page, size);
+    }
+
+    public static RankingCommand today(int page, int size) {
+        return new RankingCommand(LocalDate.now(), page, size);
+    }
+
+    private static LocalDate parseDate(String dateString) {
+        if (dateString == null || dateString.isBlank()) {
+            return LocalDate.now();
+        }
+        try {
+            return LocalDate.parse(dateString, DATE_FORMATTER);
+        } catch (DateTimeParseException e) {
+            return LocalDate.now();
+        }
+    }
+}
+

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

@@ -0,0 +1,134 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.ranking.RankingEntry;
+import com.loopers.domain.ranking.RankingInfo;
+import com.loopers.domain.ranking.RankingService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Clock;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class RankingFacade {
+
+    private final RankingService rankingService;
+    private final ProductRepository productRepository;
+    private final Clock clock;
+
+    /**
+     * 랭킹 페이지 조회
+     */
+    @Transactional(readOnly = true)
+    public RankingPageInfo getRankingPage(RankingCommand command) {
+        List<RankingEntry> entries = rankingService.getRankingPage(
+                command.date(),
+                command.page(),
+                command.size()
+        );
+
+        if (entries.isEmpty()) {
+            return RankingPageInfo.empty(command.date(), command.page(), command.size());
+        }
+
+        // 상품 정보 조회
+        List<Long> productIds = entries.stream()
+                .map(RankingEntry::productId)
+                .collect(Collectors.toList());
+
+        Map<Long, Product> productMap = productRepository.findAllByIds(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        // 랭킹 정보 조합
+        List<RankingInfo> rankings = new ArrayList<>();
+        long startRank = (long) command.page() * command.size() + 1;
+
+        for (int i = 0; i < entries.size(); i++) {
+            RankingEntry entry = entries.get(i);
+            Product product = productMap.get(entry.productId());
+
+            if (product != null) {
+                rankings.add(RankingInfo.of(
+                        product.getId(),
+                        product.getName(),
+                        product.getPriceValue(),
+                        product.getBrand().getName(),
+                        startRank + i,
+                        entry.score()
+                ));
+            }
+        }
+
+        Long totalCount = rankingService.getRankingSize(command.date());
+
+        return RankingPageInfo.of(
+                rankings,
+                command.date(),
+                command.page(),
+                command.size(),
+                totalCount
+        );
+    }
+
+    /**
+     * Top-N 랭킹 조회
+     */
+    @Transactional(readOnly = true)
+    public List<RankingInfo> getTopN(LocalDate date, int n) {
+        List<RankingEntry> entries = rankingService.getTopNWithScores(date, n);
+
+        if (entries.isEmpty()) {
+            return List.of();
+        }
+
+        List<Long> productIds = entries.stream()
+                .map(RankingEntry::productId)
+                .collect(Collectors.toList());
+
+        Map<Long, Product> productMap = productRepository.findAllByIds(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        List<RankingInfo> rankings = new ArrayList<>();
+        for (int i = 0; i < entries.size(); i++) {
+            RankingEntry entry = entries.get(i);
+            Product product = productMap.get(entry.productId());
+
+            if (product != null) {
+                rankings.add(RankingInfo.of(
+                        product.getId(),
+                        product.getName(),
+                        product.getPriceValue(),
+                        product.getBrand().getName(),
+                        (long) (i + 1),
+                        entry.score()
+                ));
+            }
+        }
+
+        return rankings;
+    }
+
+    /**
+     * 특정 상품의 순위 조회
+     */
+    public Long getProductRank(Long productId, LocalDate date) {
+        return rankingService.getRank(productId, date);
+    }
+
+    /**
+     * 특정 상품의 순위 조회 (오늘 기준)
+     */
+    public Long getProductRankToday(Long productId) {
+        return rankingService.getRank(productId, LocalDate.now(clock));
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.ranking.RankingInfo;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public record RankingPageInfo(
+        List<RankingInfo> rankings,
+        LocalDate date,
+        int page,
+        int size,
+        Long totalCount,
+        int totalPages
+) {
+    public static RankingPageInfo of(
+            List<RankingInfo> rankings,
+            LocalDate date,
+            int page,
+            int size,
+            Long totalCount
+    ) {
+        int totalPages = (int) Math.ceil((double) totalCount / size);
+        return new RankingPageInfo(rankings, date, page, size, totalCount, totalPages);
+    }
+
+    public static RankingPageInfo empty(LocalDate date, int page, int size) {
+        return new RankingPageInfo(List.of(), date, page, size, 0L, 0);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/ranking/RankingEntry.java

@@ -0,0 +1,7 @@
+package com.loopers.domain.ranking;
+
+public record RankingEntry(
+        Long productId,
+        Double score
+) {
+}

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

@@ -0,0 +1,21 @@
+package com.loopers.domain.ranking;
+
+public record RankingInfo(
+        Long productId,
+        String productName,
+        Long price,
+        String brandName,
+        Long rank,
+        Double score
+) {
+    public static RankingInfo of(
+            Long productId,
+            String productName,
+            Long price,
+            String brandName,
+            Long rank,
+            Double score
+    ) {
+        return new RankingInfo(productId, productName, price, brandName, rank, score);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/ranking/RankingKey.java

@@ -0,0 +1,20 @@
+package com.loopers.domain.ranking;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Redis ZSET 키 생성 유틸리티
+ */
+public class RankingKey {
+
+    private static final String KEY_PREFIX = "ranking:all:";
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+
+    private RankingKey() {
+    }
+
+    public static String daily(LocalDate date) {
+        return KEY_PREFIX + date.format(DATE_FORMATTER);
+    }
+}