Feat/volume 10

apps/commerce-api/build.gradle.kts

@@ -7,6 +7,9 @@ dependencies {
     implementation(project(":supports:logging"))
     implementation(project(":supports:monitoring"))
 
+    // batch
+    implementation("org.springframework.boot:spring-boot-starter-batch")
+
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
@@ -25,4 +28,7 @@ dependencies {
     // test-fixtures
     testImplementation(testFixtures(project(":modules:jpa")))
     testImplementation(testFixtures(project(":modules:redis")))
+
+    // batch test
+    testImplementation("org.springframework.batch:spring-batch-test")
 }

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

@@ -7,12 +7,15 @@
 import com.loopers.domain.product.ProductSortType;
 import com.loopers.infrastructure.cache.ProductCacheService;
 import com.loopers.infrastructure.cache.ProductDetailCache;
+import com.loopers.infrastructure.event.ViewEventPublisher;
+import com.loopers.infrastructure.ranking.RankingRedisService;
 import com.loopers.interfaces.api.product.ProductDto;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDate;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -26,6 +29,8 @@ public class ProductFacade {
     private final ProductDomainService productDomainService;
     private final BrandDomainService brandDomainService;
     private final ProductCacheService productCacheService;
+    private final ViewEventPublisher viewEventPublisher;
+    private final RankingRedisService rankingRedisService;
 
     /**
      * 상품 목록 조회 (Cache-Aside 패턴)
@@ -77,11 +82,18 @@ public ProductDto.ProductDetailResponse getProduct(Long productId) {
         // 1. 캐시 조회 시도
         Optional<ProductDetailCache> cachedDetail = productCacheService.getProductDetail(productId);
 
+        // 2. 조회 이벤트 발행 (캐시 히트 여부와 무관하게)
+        viewEventPublisher.publish(productId);
+
+        // 3. 순위 조회
+        Long rank = rankingRedisService.getRankingPosition(LocalDate.now(), productId);
+
         if (cachedDetail.isPresent()) {
             // Cache Hit: 캐시된 데이터 직접 반환
             return ProductDto.ProductDetailResponse.from(
                     productId,
-                    cachedDetail.get()
+                    cachedDetail.get(),
+                    rank
             );
         }
 
@@ -94,6 +106,6 @@ public ProductDto.ProductDetailResponse getProduct(Long productId) {
         productCacheService.setProductDetail(productId, cache);
 
         // Response 반환
-        return ProductDto.ProductDetailResponse.from(productId, cache);
+        return ProductDto.ProductDetailResponse.from(productId, cache, rank);
     }
 }

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

@@ -0,0 +1,231 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.infrastructure.ranking.ProductRankMonthly;
+import com.loopers.infrastructure.ranking.ProductRankMonthlyRepository;
+import com.loopers.infrastructure.ranking.ProductRankWeekly;
+import com.loopers.infrastructure.ranking.ProductRankWeeklyRepository;
+import com.loopers.infrastructure.ranking.RankingEntry;
+import com.loopers.infrastructure.ranking.RankingRedisService;
+import com.loopers.interfaces.api.ranking.RankingDto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Component
+@RequiredArgsConstructor
+public class RankingFacade {
+
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+
+    private final RankingRedisService rankingRedisService;
+    private final ProductRepository productRepository;
+    private final ProductRankWeeklyRepository productRankWeeklyRepository;
+    private final ProductRankMonthlyRepository productRankMonthlyRepository;
+
+    public RankingDto.RankingListResponse getRankings(String period, String dateStr, int page, int size) {
+        return switch (period.toLowerCase()) {
+            case "weekly" -> getWeeklyRankings(dateStr, page, size);
+            case "monthly" -> getMonthlyRankings(dateStr, page, size);
+            default -> getDailyRankings(dateStr, page, size);
+        };
+    }
+
+    private RankingDto.RankingListResponse getDailyRankings(String dateStr, int page, int size) {
+        LocalDate date = parseDate(dateStr);
+        int offset = page * size;
+
+        List<RankingEntry> entries = rankingRedisService.getTopProducts(date, offset, size);
+
+        if (entries.isEmpty()) {
+            return new RankingDto.RankingListResponse(List.of(), page, size, 0);
+        }
+
+        long totalCount = rankingRedisService.getTotalCount(date);
+
+        List<Long> productIds = entries.stream()
+                .map(RankingEntry::productId)
+                .toList();
+
+        Map<Long, Product> productMap = productRepository.findAllByIdIn(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        List<RankingDto.RankingResponse> rankings = new ArrayList<>();
+        int rank = offset + 1;
+        for (RankingEntry entry : entries) {
+            Product product = productMap.get(entry.productId());
+            if (product != null) {
+                rankings.add(new RankingDto.RankingResponse(
+                        rank++,
+                        product.getId(),
+                        product.getName(),
+                        product.getPrice(),
+                        entry.score()
+                ));
+            }
+        }
+
+        return new RankingDto.RankingListResponse(rankings, page, size, totalCount);
+    }
+
+    private RankingDto.RankingListResponse getWeeklyRankings(String dateStr, int page, int size) {
+        LocalDate date = parseDate(dateStr);
+        LocalDate weekStart = date.with(DayOfWeek.MONDAY);
+        int offset = page * size;
+
+        // 1. Redis 캐시 먼저 조회
+        List<RankingEntry> cachedEntries = rankingRedisService.getWeeklyRankingCache(weekStart, offset, size);
+        if (!cachedEntries.isEmpty()) {
+            long totalCount = rankingRedisService.getWeeklyRankingCacheCount(weekStart);
+            return buildRankingResponse(cachedEntries, offset, page, size, totalCount);
+        }
+
+        // 2. 캐시 없으면 DB 조회
+        List<ProductRankWeekly> weeklyRanks = productRankWeeklyRepository
+                .findByPeriodStartOrderByRankingAsc(weekStart);
+
+        if (weeklyRanks.isEmpty()) {
+            return new RankingDto.RankingListResponse(List.of(), page, size, 0);
+        }
+
+        // 3. DB 결과를 Redis에 캐시
+        List<RankingEntry> allEntries = weeklyRanks.stream()
+                .map(r -> new RankingEntry(r.getProductId(), r.getScore().doubleValue()))
+                .toList();
+        rankingRedisService.cacheWeeklyRanking(weekStart, allEntries);
+
+        // 4. 페이징 처리 후 반환
+        int toIndex = Math.min(offset + size, weeklyRanks.size());
+        if (offset >= weeklyRanks.size()) {
+            return new RankingDto.RankingListResponse(List.of(), page, size, weeklyRanks.size());
+        }
+
+        List<ProductRankWeekly> pagedRanks = weeklyRanks.subList(offset, toIndex);
+
+        List<Long> productIds = pagedRanks.stream()
+                .map(ProductRankWeekly::getProductId)
+                .toList();
+
+        Map<Long, Product> productMap = productRepository.findAllByIdIn(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        List<RankingDto.RankingResponse> rankings = new ArrayList<>();
+        for (ProductRankWeekly rank : pagedRanks) {
+            Product product = productMap.get(rank.getProductId());
+            if (product != null) {
+                rankings.add(new RankingDto.RankingResponse(
+                        rank.getRanking(),
+                        product.getId(),
+                        product.getName(),
+                        product.getPrice(),
+                        rank.getScore().doubleValue()
+                ));
+            }
+        }
+
+        return new RankingDto.RankingListResponse(rankings, page, size, weeklyRanks.size());
+    }
+
+    private RankingDto.RankingListResponse getMonthlyRankings(String dateStr, int page, int size) {
+        LocalDate date = parseDate(dateStr);
+        YearMonth yearMonth = YearMonth.from(date);
+        LocalDate monthStart = yearMonth.atDay(1);
+        int offset = page * size;
+
+        // 1. Redis 캐시 먼저 조회
+        List<RankingEntry> cachedEntries = rankingRedisService.getMonthlyRankingCache(monthStart, offset, size);
+        if (!cachedEntries.isEmpty()) {
+            long totalCount = rankingRedisService.getMonthlyRankingCacheCount(monthStart);
+            return buildRankingResponse(cachedEntries, offset, page, size, totalCount);
+        }
+
+        // 2. 캐시 없으면 DB 조회
+        List<ProductRankMonthly> monthlyRanks = productRankMonthlyRepository
+                .findByPeriodStartOrderByRankingAsc(monthStart);
+
+        if (monthlyRanks.isEmpty()) {
+            return new RankingDto.RankingListResponse(List.of(), page, size, 0);
+        }
+
+        // 3. DB 결과를 Redis에 캐시
+        List<RankingEntry> allEntries = monthlyRanks.stream()
+                .map(r -> new RankingEntry(r.getProductId(), r.getScore().doubleValue()))
+                .toList();
+        rankingRedisService.cacheMonthlyRanking(monthStart, allEntries);
+
+        // 4. 페이징 처리 후 반환
+        int toIndex = Math.min(offset + size, monthlyRanks.size());
+        if (offset >= monthlyRanks.size()) {
+            return new RankingDto.RankingListResponse(List.of(), page, size, monthlyRanks.size());
+        }
+
+        List<ProductRankMonthly> pagedRanks = monthlyRanks.subList(offset, toIndex);
+
+        List<Long> productIds = pagedRanks.stream()
+                .map(ProductRankMonthly::getProductId)
+                .toList();
+
+        Map<Long, Product> productMap = productRepository.findAllByIdIn(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        List<RankingDto.RankingResponse> rankings = new ArrayList<>();
+        for (ProductRankMonthly rank : pagedRanks) {
+            Product product = productMap.get(rank.getProductId());
+            if (product != null) {
+                rankings.add(new RankingDto.RankingResponse(
+                        rank.getRanking(),
+                        product.getId(),
+                        product.getName(),
+                        product.getPrice(),
+                        rank.getScore().doubleValue()
+                ));
+            }
+        }
+
+        return new RankingDto.RankingListResponse(rankings, page, size, monthlyRanks.size());
+    }
+
+    private RankingDto.RankingListResponse buildRankingResponse(
+            List<RankingEntry> entries, int offset, int page, int size, long totalCount) {
+
+        List<Long> productIds = entries.stream()
+                .map(RankingEntry::productId)
+                .toList();
+
+        Map<Long, Product> productMap = productRepository.findAllByIdIn(productIds).stream()
+                .collect(Collectors.toMap(Product::getId, p -> p));
+
+        List<RankingDto.RankingResponse> rankings = new ArrayList<>();
+        int rank = offset + 1;
+        for (RankingEntry entry : entries) {
+            Product product = productMap.get(entry.productId());
+            if (product != null) {
+                rankings.add(new RankingDto.RankingResponse(
+                        rank++,
+                        product.getId(),
+                        product.getName(),
+                        product.getPrice(),
+                        entry.score()
+                ));
+            }
+        }
+
+        return new RankingDto.RankingListResponse(rankings, page, size, totalCount);
+    }
+
+    private LocalDate parseDate(String dateStr) {
+        if (dateStr == null || dateStr.isBlank()) {
+            return LocalDate.now();
+        }
+        return LocalDate.parse(dateStr, DATE_FORMATTER);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/event/ProductLikedEvent.java

@@ -4,10 +4,13 @@
 
 public class ProductLikedEvent {
 
-    private final Long productId;
-    private final Long userId;
-    private final boolean liked;
-    private final LocalDateTime occurredAt;
+    private Long productId;
+    private Long userId;
+    private boolean liked;
+    private LocalDateTime occurredAt;
+
+    protected ProductLikedEvent() {
+    }
 
     private ProductLikedEvent(Long productId, Long userId, boolean liked) {
         this.productId = productId;

apps/commerce-api/src/main/java/com/loopers/domain/order/event/OrderCompletedEvent.java

@@ -3,22 +3,30 @@
 import com.loopers.domain.order.Order;
 
 import java.time.LocalDateTime;
+import java.util.List;
 
 public class OrderCompletedEvent {
 
-    private final Long orderId;
-    private final String userId;
-    private final long totalAmount;
-    private final long discountAmount;
-    private final long paymentAmount;
-    private final LocalDateTime occurredAt;
+    private Long orderId;
+    private String userId;
+    private long totalAmount;
+    private long discountAmount;
+    private long paymentAmount;
+    private List<OrderItemInfo> items;
+    private LocalDateTime occurredAt;
+
+    protected OrderCompletedEvent() {
+    }
 
     private OrderCompletedEvent(Order order) {
         this.orderId = order.getId();
         this.userId = order.getUserId();
         this.totalAmount = order.getTotalAmount();
         this.discountAmount = order.getDiscountAmount();
         this.paymentAmount = order.getPaymentAmount();
+        this.items = order.getOrderItems().stream()
+                .map(item -> new OrderItemInfo(item.getProductId(), item.getQuantity()))
+                .toList();
         this.occurredAt = LocalDateTime.now();
     }
 
@@ -46,7 +54,32 @@ public long getPaymentAmount() {
         return paymentAmount;
     }
 
+    public List<OrderItemInfo> getItems() {
+        return items;
+    }
+
     public LocalDateTime getOccurredAt() {
         return occurredAt;
     }
+
+    public static class OrderItemInfo {
+        private Long productId;
+        private Long quantity;
+
+        protected OrderItemInfo() {
+        }
+
+        public OrderItemInfo(Long productId, Long quantity) {
+            this.productId = productId;
+            this.quantity = quantity;
+        }
+
+        public Long getProductId() {
+            return productId;
+        }
+
+        public Long getQuantity() {
+            return quantity;
+        }
+    }
 }