MV 기반 주간/월간 랭킹 배치 시스템 구축

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

@@ -3,12 +3,15 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.product.ProductWithBrand;
+import com.loopers.domain.ranking.MvProductRank;
+import com.loopers.domain.ranking.MvProductRankRepository;
 import com.loopers.infrastructure.ranking.RankingRedisRepository;
 import com.loopers.interfaces.api.ranking.RankingDto;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -31,22 +34,78 @@ public class RankingFacade {
     private static final int MAX_RANKING_SIZE = 100;
 
     private static final String DAILY_ZSET_PREFIX = "ranking:all:";
-    private static final String WEEKLY_ZSET_PREFIX = "ranking:weekly:";
-    private static final String MONTHLY_ZSET_PREFIX = "ranking:monthly:";
 
     private final RankingRedisRepository rankingRedisRepository;
+    private final MvProductRankRepository mvProductRankRepository;
     private final ProductRepository productRepository;
     private final RankingProperties properties;
 
     public RankingDto.PagedRankingResponse getRankings(String scope, String date, int page, int size, Long memberId) {
         String resolvedDate = (date != null) ? date : LocalDate.now(KST).format(DATE_FORMATTER);
-        String prefix = resolveZsetPrefix(scope, memberId);
+
+        return switch (scope) {
+            case "weekly", "monthly" -> getFromMv(scope, resolvedDate, page, size);
+            default -> getFromRedis(scope, resolvedDate, page, size, memberId);
+        };
+    }
+
+    private RankingDto.PagedRankingResponse getFromMv(String scope, String date, int page, int size) {
+        // 1. 당일 MV 조회
+        List<MvProductRank> mvResults = mvProductRankRepository.findByPeriodKeyAndScope(
+            date, scope, PageRequest.of(page, size));
+        long totalElements = mvProductRankRepository.countByPeriodKeyAndScope(date, scope);
+
+        // 2. 당일 데이터 없으면 전일 fallback
+        if (mvResults.isEmpty()) {
+            String previousDate = LocalDate.parse(date, DATE_FORMATTER)
+                .minusDays(1).format(DATE_FORMATTER);
+            mvResults = mvProductRankRepository.findByPeriodKeyAndScope(
+                previousDate, scope, PageRequest.of(page, size));
+            totalElements = mvProductRankRepository.countByPeriodKeyAndScope(previousDate, scope);
+
+            if (!mvResults.isEmpty()) {
+                log.info("MV 전일 fallback 적용: scope={}, date={} → {}", scope, date, previousDate);
+            }
+        }
+
+        // 3. 전일도 없으면 빈 결과
+        if (mvResults.isEmpty()) {
+            return new RankingDto.PagedRankingResponse(List.of(), 0, 0, page, size);
+        }
+
+        totalElements = Math.min(totalElements, MAX_RANKING_SIZE);
+        int totalPages = (int) Math.ceil((double) totalElements / size);
+
+        // 4. Product 상세 조합
+        List<Long> productIds = mvResults.stream()
+            .map(MvProductRank::getProductId).toList();
+
+        Map<Long, ProductWithBrand> productMap = productRepository.findAllByIds(productIds).stream()
+            .collect(Collectors.toMap(pwb -> pwb.product().getId(), pwb -> pwb));
+
+        List<RankingDto.RankingResponse> data = new ArrayList<>();
+        for (MvProductRank mv : mvResults) {
+            ProductWithBrand pwb = productMap.get(mv.getProductId());
+            if (pwb != null) {
+                Product product = pwb.product();
+                data.add(new RankingDto.RankingResponse(
+                    mv.getProductId(), product.getName(), pwb.brandName(),
+                    product.getPrice().getValue(), mv.getRanking(), mv.getScore()
+                ));
+            }
+        }
+
+        return new RankingDto.PagedRankingResponse(data, totalElements, totalPages, page, size);
+    }
+
+    private RankingDto.PagedRankingResponse getFromRedis(String scope, String date, int page, int size, Long memberId) {
+        String prefix = resolveDailyPrefix(memberId);
 
         long totalElements;
         List<RankingRedisRepository.RankingEntry> entries;
 
         try {
-            long rawTotal = rankingRedisRepository.getTotalCount(prefix, resolvedDate);
+            long rawTotal = rankingRedisRepository.getTotalCount(prefix, date);
             totalElements = Math.min(rawTotal, MAX_RANKING_SIZE);
 
             long start = (long) page * size;
@@ -57,15 +116,14 @@ public RankingDto.PagedRankingResponse getRankings(String scope, String date, in
             }
 
             long end = Math.min(start + size - 1, totalElements - 1);
-            entries = rankingRedisRepository.getTopN(prefix, resolvedDate, start, end);
+            entries = rankingRedisRepository.getTopN(prefix, date, start, end);
         } catch (Exception e) {
             log.error("랭킹 Redis 조회 실패", e);
             throw new CoreException(ErrorType.INTERNAL_ERROR, "랭킹 서비스를 일시적으로 이용할 수 없습니다.");
         }
 
         List<Long> productIds = entries.stream()
-            .map(RankingRedisRepository.RankingEntry::productId)
-            .toList();
+            .map(RankingRedisRepository.RankingEntry::productId).toList();
 
         Map<Long, ProductWithBrand> productMap = productRepository.findAllByIds(productIds).stream()
             .collect(Collectors.toMap(pwb -> pwb.product().getId(), pwb -> pwb));
@@ -88,24 +146,15 @@ public RankingDto.PagedRankingResponse getRankings(String scope, String date, in
         return new RankingDto.PagedRankingResponse(data, totalElements, totalPages, page, size);
     }
 
-    private String resolveZsetPrefix(String scope, Long memberId) {
-        // A/B 테스트는 daily에만 적용
-        if ("daily".equals(scope) || scope == null) {
-            RankingProperties.Experiment experiment = properties.experiment();
-            if (experiment.enabled() && !experiment.variants().isEmpty() && memberId != null) {
-                List<String> variantKeys = new ArrayList<>(experiment.variants().keySet());
-                int variantIndex = (int) (Math.abs(memberId) % variantKeys.size());
-                String selectedKey = variantKeys.get(variantIndex);
-                RankingProperties.Variant variant = experiment.variants().get(selectedKey);
-                return variant.zsetPrefix();
-            }
-            return DAILY_ZSET_PREFIX;
+    private String resolveDailyPrefix(Long memberId) {
+        RankingProperties.Experiment experiment = properties.experiment();
+        if (experiment.enabled() && !experiment.variants().isEmpty() && memberId != null) {
+            List<String> variantKeys = new ArrayList<>(experiment.variants().keySet());
+            int variantIndex = (int) (Math.abs(memberId) % variantKeys.size());
+            String selectedKey = variantKeys.get(variantIndex);
+            RankingProperties.Variant variant = experiment.variants().get(selectedKey);
+            return variant.zsetPrefix();
         }
-
-        return switch (scope) {
-            case "weekly" -> WEEKLY_ZSET_PREFIX;
-            case "monthly" -> MONTHLY_ZSET_PREFIX;
-            default -> DAILY_ZSET_PREFIX;
-        };
+        return DAILY_ZSET_PREFIX;
     }
 }

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

@@ -0,0 +1,45 @@
+package com.loopers.domain.ranking;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@MappedSuperclass
+public abstract class MvProductRank {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long productId;
+
+    @Column(nullable = false)
+    private Integer ranking;
+
+    @Column(nullable = false)
+    private Double score;
+
+    @Column(nullable = false)
+    private Long viewCount;
+
+    @Column(nullable = false)
+    private Long likeCount;
+
+    @Column(nullable = false)
+    private Long salesCount;
+
+    @Column(nullable = false)
+    private Long salesAmount;
+
+    @Column(nullable = false, length = 8)
+    private String periodKey;
+
+    @Column(nullable = false)
+    private LocalDateTime createdAt;
+}

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

@@ -0,0 +1,12 @@
+package com.loopers.domain.ranking;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "mv_product_rank_monthly")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MvProductRankMonthly extends MvProductRank {
+}

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

@@ -0,0 +1,12 @@
+package com.loopers.domain.ranking;
+
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+public interface MvProductRankRepository {
+
+    List<MvProductRank> findByPeriodKeyAndScope(String periodKey, String scope, Pageable pageable);
+
+    long countByPeriodKeyAndScope(String periodKey, String scope);
+}

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

@@ -0,0 +1,12 @@
+package com.loopers.domain.ranking;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "mv_product_rank_weekly")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MvProductRankWeekly extends MvProductRank {
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/ranking/MvProductRankJpaRepository.java

@@ -0,0 +1,36 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.domain.ranking.*;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+@RequiredArgsConstructor
+public class MvProductRankJpaRepository implements MvProductRankRepository {
+
+    private final MvProductRankWeeklySpringDataRepository weeklyRepository;
+    private final MvProductRankMonthlySpringDataRepository monthlyRepository;
+
+    @Override
+    public List<MvProductRank> findByPeriodKeyAndScope(String periodKey, String scope, Pageable pageable) {
+        return switch (scope) {
+            case "weekly" -> weeklyRepository.findByPeriodKeyOrderByRankingAsc(periodKey, pageable)
+                .stream().map(r -> (MvProductRank) r).toList();
+            case "monthly" -> monthlyRepository.findByPeriodKeyOrderByRankingAsc(periodKey, pageable)
+                .stream().map(r -> (MvProductRank) r).toList();
+            default -> throw new IllegalArgumentException("Invalid scope: " + scope);
+        };
+    }
+
+    @Override
+    public long countByPeriodKeyAndScope(String periodKey, String scope) {
+        return switch (scope) {
+            case "weekly" -> weeklyRepository.countByPeriodKey(periodKey);
+            case "monthly" -> monthlyRepository.countByPeriodKey(periodKey);
+            default -> throw new IllegalArgumentException("Invalid scope: " + scope);
+        };
+    }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/ranking/MvProductRankMonthlySpringDataRepository.java

@@ -0,0 +1,14 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.domain.ranking.MvProductRankMonthly;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface MvProductRankMonthlySpringDataRepository extends JpaRepository<MvProductRankMonthly, Long> {
+
+    List<MvProductRankMonthly> findByPeriodKeyOrderByRankingAsc(String periodKey, Pageable pageable);
+
+    long countByPeriodKey(String periodKey);
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/ranking/MvProductRankWeeklySpringDataRepository.java

@@ -0,0 +1,14 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.domain.ranking.MvProductRankWeekly;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface MvProductRankWeeklySpringDataRepository extends JpaRepository<MvProductRankWeekly, Long> {
+
+    List<MvProductRankWeekly> findByPeriodKeyOrderByRankingAsc(String periodKey, Pageable pageable);
+
+    long countByPeriodKey(String periodKey);
+}