Feature/batch

apps/commerce-api/build.gradle.kts

@@ -24,9 +24,6 @@ dependencies {
     implementation("io.github.resilience4j:resilience4j-bulkhead") // Bulkheads 패턴 구현
     implementation("org.springframework.cloud:spring-cloud-starter-circuitbreaker-resilience4j")
 
-    // batch
-    implementation("org.springframework.boot:spring-boot-starter-batch")
-
     // querydsl
     annotationProcessor("com.querydsl:querydsl-apt::jakarta")
     annotationProcessor("jakarta.persistence:jakarta.persistence-api")

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

@@ -46,10 +46,49 @@ public class RankingService {
     private final ProductService productService;
     private final BrandService brandService;
     private final RankingSnapshotService rankingSnapshotService;
+    private final com.loopers.domain.rank.ProductRankRepository productRankRepository;
 
     /**
      * 랭킹을 조회합니다 (페이징).
      * <p>
+     * 기간별(일간/주간/월간) 랭킹을 조회합니다.
+     * </p>
+     * <p>
+     * <b>기간별 조회 방식:</b>
+     * <ul>
+     *   <li>DAILY: Redis ZSET에서 조회 (기존 방식)</li>
+     *   <li>WEEKLY: Materialized View에서 조회</li>
+     *   <li>MONTHLY: Materialized View에서 조회</li>
+     * </ul>
+     * </p>
+     * <p>
+     * <b>Graceful Degradation (DAILY만 적용):</b>
+     * <ul>
+     *   <li>Redis 장애 시 스냅샷으로 Fallback</li>
+     *   <li>스냅샷도 없으면 기본 랭킹(좋아요순) 제공 (단순 조회, 계산 아님)</li>
+     * </ul>
+     * </p>
+     *
+     * @param date 날짜 (yyyyMMdd 형식의 문자열 또는 LocalDate)
+     * @param periodType 기간 타입 (DAILY, WEEKLY, MONTHLY)
+     * @param page 페이지 번호 (0부터 시작)
+     * @param size 페이지당 항목 수
+     * @return 랭킹 조회 결과
+     */
+    @Transactional(readOnly = true)
+    public RankingsResponse getRankings(LocalDate date, PeriodType periodType, int page, int size) {
+        if (periodType == PeriodType.DAILY) {
+            // 일간 랭킹: 기존 Redis 방식
+            return getRankings(date, page, size);
+        } else {
+            // 주간/월간 랭킹: Materialized View에서 조회
+            return getRankingsFromMaterializedView(date, periodType, page, size);
+        }
+    }
+
+    /**
+     * 랭킹을 조회합니다 (페이징) - 일간 랭킹 전용.
+     * <p>
      * ZSET에서 상위 N개를 조회하고, 상품 정보를 Aggregation하여 반환합니다.
      * </p>
      * <p>
@@ -304,6 +343,149 @@ private Long getProductRankFromRedis(Long productId, LocalDate date) {
         return rank + 1;
     }
 
+    /**
+     * Materialized View에서 주간/월간 랭킹을 조회합니다.
+     * <p>
+     * Materialized View에 저장된 TOP 100 랭킹을 조회하고, 상품 정보를 Aggregation하여 반환합니다.
+     * </p>
+     *
+     * @param date 기준 날짜
+     * @param periodType 기간 타입 (WEEKLY 또는 MONTHLY)
+     * @param page 페이지 번호 (0부터 시작)
+     * @param size 페이지당 항목 수
+     * @return 랭킹 조회 결과
+     */
+    private RankingsResponse getRankingsFromMaterializedView(
+        LocalDate date,
+        PeriodType periodType,
+        int page,
+        int size
+    ) {
+        // 기간 시작일 계산
+        LocalDate periodStartDate;
+        if (periodType == PeriodType.WEEKLY) {
+            // 주간: 해당 주의 월요일
+            periodStartDate = date.with(java.time.DayOfWeek.MONDAY);
+        } else {
+            // 월간: 해당 월의 1일
+            periodStartDate = date.with(java.time.temporal.TemporalAdjusters.firstDayOfMonth());
+        }
+
+        // Materialized View에서 랭킹 조회
+        com.loopers.domain.rank.ProductRank.PeriodType rankPeriodType =
+            periodType == PeriodType.WEEKLY
+                ? com.loopers.domain.rank.ProductRank.PeriodType.WEEKLY
+                : com.loopers.domain.rank.ProductRank.PeriodType.MONTHLY;
+
+        List<com.loopers.domain.rank.ProductRank> ranks = productRankRepository.findByPeriod(
+            rankPeriodType, periodStartDate, 100
+        );
+
+        if (ranks.isEmpty()) {
+            return RankingsResponse.empty(page, size);
+        }
+
+        // 페이징 처리
+        long start = (long) page * size;
+        long end = Math.min(start + size, ranks.size());
+
+        if (start >= ranks.size()) {
+            return RankingsResponse.empty(page, size);
+        }
+
+        List<com.loopers.domain.rank.ProductRank> pagedRanks = ranks.subList((int) start, (int) end);
+
+        // 상품 ID 추출
+        List<Long> productIds = pagedRanks.stream()
+            .map(com.loopers.domain.rank.ProductRank::getProductId)
+            .toList();
+
+        // 상품 정보 배치 조회
+        List<Product> products = productService.getProducts(productIds);
+
+        // 상품 ID → Product Map 생성
+        Map<Long, Product> productMap = products.stream()
+            .collect(Collectors.toMap(Product::getId, product -> product));
+
+        // 브랜드 ID 수집
+        List<Long> brandIds = products.stream()
+            .map(Product::getBrandId)
+            .distinct()
+            .toList();
+
+        // 브랜드 배치 조회
+        Map<Long, Brand> brandMap = brandService.getBrands(brandIds).stream()
+            .collect(Collectors.toMap(Brand::getId, brand -> brand));
+
+        // 랭킹 항목 생성
+        List<RankingItem> rankingItems = new ArrayList<>();
+        for (com.loopers.domain.rank.ProductRank rank : pagedRanks) {
+            Long productId = rank.getProductId();
+            Product product = productMap.get(productId);
+
+            if (product == null) {
+                log.warn("랭킹에 포함된 상품을 찾을 수 없습니다: productId={}", productId);
+                continue;
+            }
+
+            Brand brand = brandMap.get(product.getBrandId());
+            if (brand == null) {
+                log.warn("상품의 브랜드를 찾을 수 없습니다: productId={}, brandId={}", 
+                    productId, product.getBrandId());
+                continue;
+            }
+
+            ProductDetail productDetail = ProductDetail.from(
+                product, 
+                brand.getName(), 
+                rank.getLikeCount()
+            );
+
+            // 종합 점수 계산 (Materialized View에는 저장되지 않으므로 계산)
+            double score = calculateScore(rank.getLikeCount(), rank.getSalesCount(), rank.getViewCount());
+
+            rankingItems.add(new RankingItem(
+                rank.getRank().longValue(),
+                score,
+                productDetail
+            ));
+        }
+
+        boolean hasNext = end < ranks.size();
+        return new RankingsResponse(rankingItems, page, size, hasNext);
+    }
+
+    /**
+     * 종합 점수를 계산합니다.
+     * <p>
+     * 가중치:
+     * <ul>
+     *   <li>좋아요: 0.3</li>
+     *   <li>판매량: 0.5</li>
+     *   <li>조회수: 0.2</li>
+     * </ul>
+     * </p>
+     *
+     * @param likeCount 좋아요 수
+     * @param salesCount 판매량
+     * @param viewCount 조회 수
+     * @return 종합 점수
+     */
+    private double calculateScore(Long likeCount, Long salesCount, Long viewCount) {
+        return (likeCount != null ? likeCount : 0L) * 0.3
+            + (salesCount != null ? salesCount : 0L) * 0.5
+            + (viewCount != null ? viewCount : 0L) * 0.2;
+    }
+
+    /**
+     * 기간 타입 열거형.
+     */
+    public enum PeriodType {
+        DAILY,   // 일간
+        WEEKLY,  // 주간
+        MONTHLY  // 월간
+    }
+
     /**
      * 랭킹 조회 결과.
      *

apps/commerce-api/src/main/java/com/loopers/domain/rank/ProductRank.java

@@ -0,0 +1,119 @@
+package com.loopers.domain.rank;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 상품 랭킹 Materialized View 엔티티.
+ * <p>
+ * 주간/월간 TOP 100 랭킹을 저장하는 조회 전용 테이블입니다.
+ * </p>
+ * <p>
+ * <b>Materialized View 설계:</b>
+ * <ul>
+ *   <li>주간 랭킹: `mv_product_rank_weekly` (period_type = WEEKLY)</li>
+ *   <li>월간 랭킹: `mv_product_rank_monthly` (period_type = MONTHLY)</li>
+ *   <li>TOP 100만 저장하여 조회 성능 최적화</li>
+ * </ul>
+ * </p>
+ * <p>
+ * <b>인덱스 전략:</b>
+ * <ul>
+ *   <li>복합 인덱스: (period_type, period_start_date, rank) - 기간별 랭킹 조회 최적화</li>
+ *   <li>복합 인덱스: (period_type, period_start_date, product_id) - 특정 상품 랭킹 조회 최적화</li>
+ * </ul>
+ * </p>
+ *
+ * @author Loopers
+ * @version 1.0
+ */
+@Entity
+@Table(
+    name = "mv_product_rank",
+    indexes = {
+        @Index(name = "idx_period_type_start_date_rank", columnList = "period_type, period_start_date, rank"),
+        @Index(name = "idx_period_type_start_date_product_id", columnList = "period_type, period_start_date, product_id")
+    }
+)
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+public class ProductRank {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    /**
+     * 기간 타입 (WEEKLY: 주간, MONTHLY: 월간)
+     */
+    @Enumerated(EnumType.STRING)
+    @Column(name = "period_type", nullable = false, length = 20)
+    private PeriodType periodType;
+
+    /**
+     * 기간 시작일
+     * <ul>
+     *   <li>주간: 해당 주의 월요일 (ISO 8601 기준)</li>
+     *   <li>월간: 해당 월의 1일</li>
+     * </ul>
+     */
+    @Column(name = "period_start_date", nullable = false)
+    private LocalDate periodStartDate;
+
+    /**
+     * 상품 ID
+     */
+    @Column(name = "product_id", nullable = false)
+    private Long productId;
+
+    /**
+     * 랭킹 (1-100)
+     */
+    @Column(name = "rank", nullable = false)
+    private Integer rank;
+
+    /**
+     * 좋아요 수
+     */
+    @Column(name = "like_count", nullable = false)
+    private Long likeCount;
+
+    /**
+     * 판매량
+     */
+    @Column(name = "sales_count", nullable = false)
+    private Long salesCount;
+
+    /**
+     * 조회 수
+     */
+    @Column(name = "view_count", nullable = false)
+    private Long viewCount;
+
+    /**
+     * 생성 시각
+     */
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    /**
+     * 수정 시각
+     */
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    /**
+     * 기간 타입 열거형.
+     */
+    public enum PeriodType {
+        WEEKLY,  // 주간
+        MONTHLY  // 월간
+    }
+}
+

apps/commerce-api/src/main/java/com/loopers/domain/rank/ProductRankRepository.java

@@ -0,0 +1,39 @@
+package com.loopers.domain.rank;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * ProductRank 도메인 Repository 인터페이스.
+ * <p>
+ * Materialized View에 저장된 상품 랭킹 데이터를 조회합니다.
+ * </p>
+ */
+public interface ProductRankRepository {
+
+    /**
+     * 특정 기간의 랭킹 데이터를 조회합니다.
+     *
+     * @param periodType 기간 타입
+     * @param periodStartDate 기간 시작일
+     * @param limit 조회할 랭킹 수 (기본: 100)
+     * @return 랭킹 리스트 (rank 오름차순)
+     */
+    List<ProductRank> findByPeriod(ProductRank.PeriodType periodType, LocalDate periodStartDate, int limit);
+
+    /**
+     * 특정 기간의 특정 상품 랭킹을 조회합니다.
+     *
+     * @param periodType 기간 타입
+     * @param periodStartDate 기간 시작일
+     * @param productId 상품 ID
+     * @return 랭킹 정보 (없으면 Optional.empty())
+     */
+    Optional<ProductRank> findByPeriodAndProductId(
+        ProductRank.PeriodType periodType,
+        LocalDate periodStartDate,
+        Long productId
+    );
+}
+