feat(ranking): 상품 메트릭 집계 로직 개선

- 집계 쿼리 결과를 Object[]에서 ProductMetricsAggregation으로 변경
- 랭킹 집계 로직에서 DTO 변환 및 점수 계산 방식 개선
- rankPosition 타입을 long에서 int로 변경하여 일관성 강화

Author: hyujikoh

apps/commerce-batch/src/main/java/com/loopers/batch/job/ranking/dto/RankingAggregation.java

@@ -3,6 +3,7 @@
 import java.math.BigDecimal;
 
 import com.loopers.batch.job.ranking.support.ScoreCalculator;
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 
 import lombok.Getter;
 
@@ -38,30 +39,31 @@ private RankingAggregation(Long productId, long viewCount, long likeCount,
     /**
      * DB 집계 결과로부터 RankingAggregation을 생성합니다.
      *
-     * @param row        DB 집계 쿼리 결과 (Object[] 형태)
+     * @param metrics    상품 메트릭 집계 결과 DTO
      * @param calculator 점수 계산기
      * @return 생성된 RankingAggregation 객체
-     * @throws IllegalArgumentException row가 null이거나 형식이 잘못된 경우
+     * @throws IllegalArgumentException metrics가 null인 경우
      */
-    public static RankingAggregation from(Object[] row, ScoreCalculator calculator) {
-        if (row == null || row.length < 6) {
-            throw new IllegalArgumentException("집계 결과 배열이 null이거나 길이가 부족합니다.");
+    public static RankingAggregation from(ProductMetricsAggregation metrics, ScoreCalculator calculator) {
+        if (metrics == null) {
+            throw new IllegalArgumentException("집계 결과(metrics)가 null입니다.");
         }
 
-        try {
-            Long productId = (Long) row[0];
-            long viewCount = ((Number) row[1]).longValue();
-            long likeCount = ((Number) row[2]).longValue();
-            long salesCount = ((Number) row[3]).longValue();
-            long orderCount = ((Number) row[4]).longValue();
-            BigDecimal totalSalesAmount = (BigDecimal) row[5];
+        long totalScore = calculator.calculate(
+                metrics.viewCount(),
+                metrics.likeCount(),
+                metrics.totalSalesAmount()
+        );
 
-            long totalScore = calculator.calculate(viewCount, likeCount, totalSalesAmount);
-
-            return new RankingAggregation(productId, viewCount, likeCount, salesCount, orderCount, totalSalesAmount, totalScore);
-        } catch (ClassCastException | NullPointerException e) {
-            throw new IllegalArgumentException("집계 결과 데이터 형식이 올바르지 않습니다.", e);
-        }
+        return new RankingAggregation(
+                metrics.productId(),
+                metrics.viewCount(),
+                metrics.likeCount(),
+                metrics.salesCount(),
+                metrics.orderCount(),
+                metrics.totalSalesAmount(),
+                totalScore
+        );
     }
 
     /**

apps/commerce-batch/src/main/java/com/loopers/batch/job/ranking/reader/AbstractMetricsReader.java

@@ -8,6 +8,7 @@
 
 import com.loopers.batch.job.ranking.dto.RankingAggregation;
 import com.loopers.batch.job.ranking.support.RankingAggregator;
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 import com.loopers.domain.metrics.ProductMetricsRepository;
 
 import lombok.extern.slf4j.Slf4j;
@@ -54,7 +55,7 @@ private void initializeIterator() {
             log.info("집계 기간: {} ~ {}", startDate, endDate);
 
             // 2. DB에서 집계 쿼리 실행
-            List<Object[]> aggregationResults = productMetricsRepository.aggregateByDateRange(startDate, endDate);
+            List<ProductMetricsAggregation> aggregationResults = productMetricsRepository.aggregateByDateRange(startDate, endDate);
             log.info("집계 대상 상품 수: {}", aggregationResults.size());
 
             // 3. 랭킹 처리 (정렬 + TOP 100 + 순위 부여)

apps/commerce-batch/src/main/java/com/loopers/batch/job/ranking/support/RankingAggregator.java

@@ -3,6 +3,7 @@
 import java.util.Comparator;
 import java.util.List;
 
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 import org.springframework.stereotype.Component;
 
 import com.loopers.batch.job.ranking.dto.RankingAggregation;
@@ -29,14 +30,14 @@ public class RankingAggregator {
      * @param aggregationResults DB 집계 쿼리 결과 목록
      * @return TOP 100 랭킹 목록 (순위 부여 완료)
      */
-    public List<RankingAggregation> processRankings(List<Object[]> aggregationResults) {
+    public List<RankingAggregation> processRankings(List<ProductMetricsAggregation> aggregationResults) {
         if (aggregationResults == null || aggregationResults.isEmpty()) {
             return List.of();
         }
 
         // 1. DTO 변환 + 점수 계산
         List<RankingAggregation> aggregations = aggregationResults.stream()
-                .map(row -> RankingAggregation.from(row, scoreCalculator))
+                .map(metrics -> RankingAggregation.from(metrics, scoreCalculator))
                 .toList();
 
         // 2. 점수 기준 내림차순 정렬 + TOP 100 필터링

apps/commerce-batch/src/main/java/com/loopers/infrastructure/metrics/ProductMetricsJpaRepository.java

@@ -3,6 +3,7 @@
 import java.time.LocalDate;
 import java.util.List;
 
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
@@ -22,20 +23,21 @@ public interface ProductMetricsJpaRepository extends JpaRepository<ProductMetric
      *
      * @param startDate 시작 날짜 (포함)
      * @param endDate   종료 날짜 (포함)
-     * @return 집계 결과 [productId, viewCount, likeCount, salesCount, orderCount, totalSalesAmount]
+     * @return 집계 결과 목록
      */
     @Query("""
-            SELECT m.id.productId, 
+            SELECT new com.loopers.domain.metrics.ProductMetricsAggregation(
+                   m.id.productId, 
                    SUM(m.viewCount), 
                    SUM(m.likeCount), 
                    SUM(m.salesCount), 
                    SUM(m.orderCount),
-                   SUM(m.totalSalesAmount)
+                   SUM(m.totalSalesAmount))
             FROM ProductMetricsEntity m 
             WHERE m.id.metricDate BETWEEN :startDate AND :endDate
             GROUP BY m.id.productId
             """)
-    List<Object[]> aggregateByDateRange(
+    List<ProductMetricsAggregation> aggregateByDateRange(
             @Param("startDate") LocalDate startDate,
             @Param("endDate") LocalDate endDate);
 

apps/commerce-batch/src/main/java/com/loopers/infrastructure/metrics/ProductMetricsRepositoryImpl.java

@@ -4,6 +4,7 @@
 import java.util.List;
 import java.util.Optional;
 
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 import org.springframework.stereotype.Repository;
 
 import com.loopers.domain.metrics.ProductMetricsEntity;
@@ -44,7 +45,7 @@ public List<ProductMetricsEntity> findByMetricDateBetween(LocalDate startDate, L
     }
 
     @Override
-    public List<Object[]> aggregateByDateRange(LocalDate startDate, LocalDate endDate) {
+    public List<ProductMetricsAggregation> aggregateByDateRange(LocalDate startDate, LocalDate endDate) {
         return jpaRepository.aggregateByDateRange(startDate, endDate);
     }
 }

apps/commerce-batch/src/test/java/com/loopers/batch/job/ranking/dto/RankingAggregationUnitTest.java

@@ -6,6 +6,7 @@
 import org.junit.jupiter.api.Test;
 
 import com.loopers.batch.job.ranking.support.ScoreCalculator;
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 
 @DisplayName("RankingAggregation 단위 테스트")
 class RankingAggregationUnitTest {
@@ -20,10 +21,12 @@ class 집계_결과로부터_생성 {
         @DisplayName("유효한 집계 결과로부터 객체를 생성한다")
         void should_create_from_valid_aggregation_result() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)}; // productId, view, like, sales, order, amount
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
 
             // when
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
 
             // then
             Assertions.assertThat(aggregation.getProductId()).isEqualTo(1L);
@@ -38,52 +41,12 @@ void should_create_from_valid_aggregation_result() {
         }
 
         @Test
-        @DisplayName("null 배열에 대해 예외가 발생한다")
-        void should_throw_exception_when_row_is_null() {
+        @DisplayName("null 메트릭에 대해 예외가 발생한다")
+        void should_throw_exception_when_metrics_is_null() {
             // given & when & then
             Assertions.assertThatThrownBy(() -> RankingAggregation.from(null, calculator))
                     .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("집계 결과 배열이 null이거나 길이가 부족합니다");
-        }
-
-        @Test
-        @DisplayName("길이가 부족한 배열에 대해 예외가 발생한다")
-        void should_throw_exception_when_row_length_is_insufficient() {
-            // given
-            Object[] shortRow = {1L, 100L, 50L}; // 길이 3 (6 미만)
-
-            // when & then
-            Assertions.assertThatThrownBy(() -> RankingAggregation.from(shortRow, calculator))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("집계 결과 배열이 null이거나 길이가 부족합니다");
-        }
-
-        @Test
-        @DisplayName("잘못된 데이터 타입에 대해 예외가 발생한다")
-        void should_throw_exception_when_data_type_is_invalid() {
-            // given
-            Object[] invalidRow = {"invalid", 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)}; // productId가 String
-
-            // when & then
-            Assertions.assertThatThrownBy(() -> RankingAggregation.from(invalidRow, calculator))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("집계 결과 데이터 형식이 올바르지 않습니다");
-        }
-
-        @Test
-        @DisplayName("Number 타입의 다양한 형태를 처리한다")
-        void should_handle_various_number_types() {
-            // given - Integer, Long, BigDecimal 등 다양한 Number 타입
-            Object[] row = {1L, 100, 50L, 10, 5L, java.math.BigDecimal.valueOf(1000)};
-
-            // when
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
-
-            // then
-            Assertions.assertThat(aggregation.getViewCount()).isEqualTo(100L);
-            Assertions.assertThat(aggregation.getLikeCount()).isEqualTo(50L);
-            Assertions.assertThat(aggregation.getSalesCount()).isEqualTo(10L);
-            Assertions.assertThat(aggregation.getOrderCount()).isEqualTo(5L);
+                    .hasMessageContaining("집계 결과(metrics)가 null입니다.");
         }
     }
 
@@ -95,8 +58,10 @@ class 순위_부여 {
         @DisplayName("유효한 순위를 부여한다")
         void should_assign_valid_rank() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)};
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
 
             // when
             aggregation.assignRank(1);
@@ -109,8 +74,10 @@ void should_assign_valid_rank() {
         @DisplayName("100위까지 순위를 부여할 수 있다")
         void should_assign_rank_up_to_100() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)};
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
 
             // when
             aggregation.assignRank(100);
@@ -123,8 +90,10 @@ void should_assign_rank_up_to_100() {
         @DisplayName("0 이하의 순위에 대해 예외가 발생한다")
         void should_throw_exception_when_rank_is_zero_or_negative() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)};
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
 
             // when & then
             Assertions.assertThatThrownBy(() -> aggregation.assignRank(0))
@@ -140,8 +109,10 @@ void should_throw_exception_when_rank_is_zero_or_negative() {
         @DisplayName("100을 초과하는 순위에 대해 예외가 발생한다")
         void should_throw_exception_when_rank_exceeds_100() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)};
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
 
             // when & then
             Assertions.assertThatThrownBy(() -> aggregation.assignRank(101))
@@ -158,8 +129,10 @@ class 문자열_표현 {
         @DisplayName("toString이 올바른 형식을 반환한다")
         void should_return_correct_string_format() {
             // given
-            Object[] row = {1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)};
-            RankingAggregation aggregation = RankingAggregation.from(row, calculator);
+            ProductMetricsAggregation metrics = new ProductMetricsAggregation(
+                    1L, 100L, 50L, 10L, 5L, java.math.BigDecimal.valueOf(1000)
+            );
+            RankingAggregation aggregation = RankingAggregation.from(metrics, calculator);
             aggregation.assignRank(1);
 
             // when

apps/commerce-batch/src/test/java/com/loopers/batch/job/ranking/support/RankingAggregatorUnitTest.java

@@ -4,6 +4,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import com.loopers.domain.metrics.ProductMetricsAggregation;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -25,10 +26,10 @@ class 랭킹_처리 {
         @DisplayName("집계 결과를 점수 기준으로 정렬하고 순위를 부여한다")
         void should_sort_by_score_and_assign_ranks() {
             // given
-            List<Object[]> results = List.of(
-                    new Object[]{1L, 100L, 10L, 5L, 2L , new BigDecimal(0)},
-                    new Object[]{2L, 200L, 20L, 10L, 4L, new BigDecimal(0)},
-                    new Object[]{3L, 50L, 5L, 2L, 1L, new BigDecimal(0)}
+            List<ProductMetricsAggregation> results = List.of(
+                    new ProductMetricsAggregation(1L, 100L, 10L, 5L, 2L , new BigDecimal(0)),
+                    new ProductMetricsAggregation(2L, 200L, 20L, 10L, 4L, new BigDecimal(0)),
+                    new ProductMetricsAggregation(3L, 50L, 5L, 2L, 1L, new BigDecimal(0))
             );
 
             // when
@@ -40,25 +41,25 @@ void should_sort_by_score_and_assign_ranks() {
             // 점수 기준 내림차순 정렬 확인
             Assertions.assertThat(rankings.get(0).getProductId()).isEqualTo(2L); // 1위
             Assertions.assertThat(rankings.get(0).getRankPosition()).isEqualTo(1);
-            Assertions.assertThat(rankings.get(0).getTotalScore()).isEqualTo(240L);
-
+            Assertions.assertThat(rankings.get(0).getTotalScore()).isEqualTo(240L); // (200*0.1 + 20*0.2 + log(1)*0.6) * 10 = (20 + 4 + 0) * 10 = 240
+            
             Assertions.assertThat(rankings.get(1).getProductId()).isEqualTo(1L); // 2위
             Assertions.assertThat(rankings.get(1).getRankPosition()).isEqualTo(2);
-            Assertions.assertThat(rankings.get(1).getTotalScore()).isEqualTo(120L);
+            Assertions.assertThat(rankings.get(1).getTotalScore()).isEqualTo(120L); // (100*0.1 + 10*0.2) * 10 = 120
 
             Assertions.assertThat(rankings.get(2).getProductId()).isEqualTo(3L); // 3위
             Assertions.assertThat(rankings.get(2).getRankPosition()).isEqualTo(3);
-            Assertions.assertThat(rankings.get(2).getTotalScore()).isEqualTo(60L);
+            Assertions.assertThat(rankings.get(2).getTotalScore()).isEqualTo(60L); // (50*0.1 + 5*0.2) * 10 = 60
         }
 
         @Test
         @DisplayName("TOP 100을 초과하는 결과는 필터링된다")
         void should_filter_results_beyond_top_100() {
             // given - 150개의 결과 생성
-            List<Object[]> results = new ArrayList<>();
+            List<ProductMetricsAggregation> results = new ArrayList<>();
             for (int i = 1; i <= 150; i++) {
                 // 점수가 높은 순서대로 생성 (i가 클수록 점수 높음)
-                results.add(new Object[]{(long) i, (long) i * 10, (long) i, (long) i, (long) i, new BigDecimal(i)});
+                results.add(new ProductMetricsAggregation((long) i, (long) i * 10, (long) i, (long) i, (long) i, new BigDecimal(i)));
             }
 
             // when
@@ -74,7 +75,7 @@ void should_filter_results_beyond_top_100() {
         @DisplayName("빈 결과에 대해 빈 목록을 반환한다")
         void should_return_empty_list_for_empty_results() {
             // given
-            List<Object[]> emptyResults = List.of();
+            List<ProductMetricsAggregation> emptyResults = List.of();
 
             // when
             List<RankingAggregation> rankings = aggregator.processRankings(emptyResults);
@@ -97,10 +98,10 @@ void should_return_empty_list_for_null_results() {
         @DisplayName("동일한 점수의 상품들은 순서가 유지된다")
         void should_maintain_order_for_same_scores() {
             // given - 동일한 점수를 가진 상품들
-            List<Object[]> results = List.of(
-                    new Object[]{1L, 100L, 0L, 0L, 0L, new BigDecimal(0)}, // score = 100
-                    new Object[]{2L, 100L, 0L, 0L, 0L, new BigDecimal(0)}, // score = 100
-                    new Object[]{3L, 100L, 0L, 0L, 0L, new BigDecimal(0)}  // score = 100
+            List<ProductMetricsAggregation> results = List.of(
+                    new ProductMetricsAggregation(1L, 100L, 0L, 0L, 0L, new BigDecimal(0)), // score = 100
+                    new ProductMetricsAggregation(2L, 100L, 0L, 0L, 0L, new BigDecimal(0)), // score = 100
+                    new ProductMetricsAggregation(3L, 100L, 0L, 0L, 0L, new BigDecimal(0))  // score = 100
             );
 
             // when