[Volume - 10] Spring Batch 기반 주간/월간 랭킹 집계 시스템 구현

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

@@ -3,7 +3,9 @@
 import com.loopers.domain.model.brand.Brand;
 import com.loopers.domain.model.common.PageResult;
 import com.loopers.domain.model.product.Product;
+import com.loopers.domain.model.ranking.RankingPeriod;
 import com.loopers.domain.repository.BrandRepository;
+import com.loopers.domain.repository.PeriodRankingRepository;
 import com.loopers.domain.repository.ProductRepository;
 import com.loopers.domain.repository.RankingRepository;
 import com.loopers.domain.repository.RankingRepository.RankedProduct;
@@ -21,27 +23,51 @@
 public class RankingQueryService implements RankingQueryUseCase {
 
     private final RankingRepository rankingRepository;
+    private final PeriodRankingRepository periodRankingRepository;
     private final ProductRepository productRepository;
     private final BrandRepository brandRepository;
 
     public RankingQueryService(RankingRepository rankingRepository,
+                               PeriodRankingRepository periodRankingRepository,
                                ProductRepository productRepository,
                                BrandRepository brandRepository) {
         this.rankingRepository = rankingRepository;
+        this.periodRankingRepository = periodRankingRepository;
         this.productRepository = productRepository;
         this.brandRepository = brandRepository;
     }
 
     @Override
     public PageResult<RankingItemInfo> getRankings(LocalDate date, int page, int size) {
+        return getRankings(date, page, size, RankingPeriod.DAILY);
+    }
+
+    @Override
+    public PageResult<RankingItemInfo> getRankings(LocalDate date, int page, int size, RankingPeriod period) {
         int offset = page * size;
-        List<RankedProduct> rankedProducts = rankingRepository.getTopRankings(date, offset, size);
+
+        List<RankedProduct> rankedProducts;
+        long totalCount;
+
+        switch (period) {
+            case WEEKLY -> {
+                rankedProducts = periodRankingRepository.getWeeklyRankings(date, offset, size);
+                totalCount = periodRankingRepository.getWeeklyTotalCount(date);
+            }
+            case MONTHLY -> {
+                rankedProducts = periodRankingRepository.getMonthlyRankings(date, offset, size);
+                totalCount = periodRankingRepository.getMonthlyTotalCount(date);
+            }
+            default -> {
+                rankedProducts = rankingRepository.getTopRankings(date, offset, size);
+                totalCount = rankingRepository.getTotalCount(date);
+            }
+        }
 
         if (rankedProducts.isEmpty()) {
             return new PageResult<>(Collections.emptyList(), page, size, 0, 0);
         }
 
-        long totalCount = rankingRepository.getTotalCount(date);
         int totalPages = (int) Math.ceil((double) totalCount / size);
 
         List<Long> productIds = rankedProducts.stream()

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

@@ -1,13 +1,16 @@
 package com.loopers.application.ranking;
 
 import com.loopers.domain.model.common.PageResult;
+import com.loopers.domain.model.ranking.RankingPeriod;
 
 import java.time.LocalDate;
 
 public interface RankingQueryUseCase {
 
     PageResult<RankingItemInfo> getRankings(LocalDate date, int page, int size);
 
+    PageResult<RankingItemInfo> getRankings(LocalDate date, int page, int size, RankingPeriod period);
+
     Long getProductRank(LocalDate date, Long productId);
 
     record RankingItemInfo(

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

@@ -0,0 +1,7 @@
+package com.loopers.domain.model.ranking;
+
+public enum RankingPeriod {
+    DAILY,
+    WEEKLY,
+    MONTHLY
+}

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

@@ -0,0 +1,24 @@
+package com.loopers.domain.model.ranking;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.WeekFields;
+import java.util.Locale;
+
+public final class RankingPeriodKeyResolver {
+
+    private static final DateTimeFormatter YEAR_MONTH_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM");
+
+    private RankingPeriodKeyResolver() {}
+
+    public static String toYearWeek(LocalDate date) {
+        WeekFields weekFields = WeekFields.of(Locale.KOREA);
+        int year = date.getYear();
+        int week = date.get(weekFields.weekOfWeekBasedYear());
+        return String.format("%d-W%02d", year, week);
+    }
+
+    public static String toYearMonth(LocalDate date) {
+        return date.format(YEAR_MONTH_FORMAT);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/repository/PeriodRankingRepository.java

@@ -0,0 +1,17 @@
+package com.loopers.domain.repository;
+
+import com.loopers.domain.repository.RankingRepository.RankedProduct;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public interface PeriodRankingRepository {
+
+    List<RankedProduct> getWeeklyRankings(LocalDate date, int offset, int size);
+
+    long getWeeklyTotalCount(LocalDate date);
+
+    List<RankedProduct> getMonthlyRankings(LocalDate date, int offset, int size);
+
+    long getMonthlyTotalCount(LocalDate date);
+}

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

@@ -0,0 +1,51 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.domain.model.ranking.RankingPeriodKeyResolver;
+import com.loopers.domain.repository.PeriodRankingRepository;
+import com.loopers.domain.repository.RankingRepository.RankedProduct;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Repository
+public class JpaPeriodRankingRepository implements PeriodRankingRepository {
+
+    private final ProductRankWeeklyJpaRepository weeklyRepository;
+    private final ProductRankMonthlyJpaRepository monthlyRepository;
+
+    public JpaPeriodRankingRepository(ProductRankWeeklyJpaRepository weeklyRepository,
+                                      ProductRankMonthlyJpaRepository monthlyRepository) {
+        this.weeklyRepository = weeklyRepository;
+        this.monthlyRepository = monthlyRepository;
+    }
+
+    @Override
+    public List<RankedProduct> getWeeklyRankings(LocalDate date, int offset, int size) {
+        String yearWeek = RankingPeriodKeyResolver.toYearWeek(date);
+        PageRequest pageable = PageRequest.of(offset / size, size);
+        return weeklyRepository.findByYearWeekOrderByRanking(yearWeek, pageable).stream()
+                .map(e -> new RankedProduct(e.getProductId(), e.getScore(), e.getRanking() - 1L))
+                .toList();
+    }
+
+    @Override
+    public long getWeeklyTotalCount(LocalDate date) {
+        return weeklyRepository.countByYearWeek(RankingPeriodKeyResolver.toYearWeek(date));
+    }
+
+    @Override
+    public List<RankedProduct> getMonthlyRankings(LocalDate date, int offset, int size) {
+        String yearMonth = RankingPeriodKeyResolver.toYearMonth(date);
+        PageRequest pageable = PageRequest.of(offset / size, size);
+        return monthlyRepository.findByYearMonthOrderByRanking(yearMonth, pageable).stream()
+                .map(e -> new RankedProduct(e.getProductId(), e.getScore(), e.getRanking() - 1L))
+                .toList();
+    }
+
+    @Override
+    public long getMonthlyTotalCount(LocalDate date) {
+        return monthlyRepository.countByYearMonth(RankingPeriodKeyResolver.toYearMonth(date));
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.infrastructure.ranking.entity.ProductRankMonthlyJpaEntity;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface ProductRankMonthlyJpaRepository extends JpaRepository<ProductRankMonthlyJpaEntity, Long> {
+
+    @Query("SELECT e FROM ProductRankMonthlyJpaEntity e WHERE e.yearMonth = :yearMonth ORDER BY e.ranking ASC")
+    List<ProductRankMonthlyJpaEntity> findByYearMonthOrderByRanking(
+            @Param("yearMonth") String yearMonth, Pageable pageable);
+
+    long countByYearMonth(String yearMonth);
+}

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

@@ -0,0 +1,18 @@
+package com.loopers.infrastructure.ranking;
+
+import com.loopers.infrastructure.ranking.entity.ProductRankWeeklyJpaEntity;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface ProductRankWeeklyJpaRepository extends JpaRepository<ProductRankWeeklyJpaEntity, Long> {
+
+    @Query("SELECT e FROM ProductRankWeeklyJpaEntity e WHERE e.yearWeek = :yearWeek ORDER BY e.ranking ASC")
+    List<ProductRankWeeklyJpaEntity> findByYearWeekOrderByRanking(
+            @Param("yearWeek") String yearWeek, Pageable pageable);
+
+    long countByYearWeek(String yearWeek);
+}

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

@@ -0,0 +1,46 @@
+package com.loopers.infrastructure.ranking.entity;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(name = "mv_product_rank_monthly")
+public class ProductRankMonthlyJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long productId;
+
+    @Column(nullable = false, length = 7)
+    private String yearMonth;
+
+    @Column(nullable = false)
+    private long likeCount;
+
+    @Column(nullable = false)
+    private long orderCount;
+
+    @Column(nullable = false)
+    private long viewCount;
+
+    @Column(nullable = false)
+    private long totalSalesAmount;
+
+    @Column(nullable = false)
+    private double score;
+
+    @Column(nullable = false)
+    private int ranking;
+
+    @Column(nullable = false)
+    private LocalDateTime updatedAt;
+}

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

@@ -0,0 +1,46 @@
+package com.loopers.infrastructure.ranking.entity;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(name = "mv_product_rank_weekly")
+public class ProductRankWeeklyJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long productId;
+
+    @Column(nullable = false, length = 7)
+    private String yearWeek;
+
+    @Column(nullable = false)
+    private long likeCount;
+
+    @Column(nullable = false)
+    private long orderCount;
+
+    @Column(nullable = false)
+    private long viewCount;
+
+    @Column(nullable = false)
+    private long totalSalesAmount;
+
+    @Column(nullable = false)
+    private double score;
+
+    @Column(nullable = false)
+    private int ranking;
+
+    @Column(nullable = false)
+    private LocalDateTime updatedAt;
+}

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

@@ -2,6 +2,7 @@
 
 import com.loopers.application.ranking.RankingQueryUseCase;
 import com.loopers.domain.model.common.PageResult;
+import com.loopers.domain.model.ranking.RankingPeriod;
 import com.loopers.interfaces.api.common.PageResponse;
 import com.loopers.interfaces.api.ranking.dto.RankingItemResponse;
 import org.springframework.format.annotation.DateTimeFormat;
@@ -27,12 +28,13 @@ public RankingController(RankingQueryUseCase rankingQueryUseCase) {
     public ResponseEntity<PageResponse<RankingItemResponse>> getRankings(
             @RequestParam(required = false) @DateTimeFormat(pattern = "yyyyMMdd") LocalDate date,
             @RequestParam(defaultValue = "20") int size,
-            @RequestParam(defaultValue = "0") int page
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "DAILY") RankingPeriod period
     ) {
         LocalDate targetDate = date != null ? date : LocalDate.now();
 
         PageResult<RankingQueryUseCase.RankingItemInfo> rankings =
-                rankingQueryUseCase.getRankings(targetDate, page, size);
+                rankingQueryUseCase.getRankings(targetDate, page, size, period);
 
         return ResponseEntity.ok(PageResponse.from(rankings, RankingItemResponse::from));
     }

apps/commerce-batch/src/main/java/com/loopers/batch/infrastructure/entity/ProductMetricsEntity.java

@@ -0,0 +1,33 @@
+package com.loopers.batch.infrastructure.entity;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(name = "product_metrics")
+public class ProductMetricsEntity {
+
+    @Id
+    private Long productId;
+
+    @Column(nullable = false)
+    private long likeCount;
+
+    @Column(nullable = false)
+    private long orderCount;
+
+    @Column(nullable = false)
+    private long viewCount;
+
+    @Column(nullable = false)
+    private long totalSalesAmount;
+
+    @Column(nullable = false)
+    private LocalDateTime updatedAt;
+}