[volume-10] Collect, Stack, Zip

apps/commerce-api/src/main/java/com/loopers/CommerceApiApplication.java

@@ -6,13 +6,15 @@
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.EnableAsync;
 
 import java.util.TimeZone;
 
 @EnableFeignClients
 @ConfigurationPropertiesScan
 @SpringBootApplication
 @EnableScheduling
+@EnableAsync
 public class CommerceApiApplication {
 
     @PostConstruct

apps/commerce-api/src/main/java/com/loopers/application/like/LikeEventHandler.java

@@ -7,6 +7,8 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.event.TransactionalEventListener;
 
 import static org.springframework.transaction.event.TransactionPhase.AFTER_COMMIT;
@@ -20,6 +22,7 @@ public class LikeEventHandler {
 
     @Async
     @TransactionalEventListener(phase = AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void handleLikeCreated(LikeCreatedEvent event) {
         try {
             productRepository.findByIdForUpdate(event.productId())
@@ -38,6 +41,7 @@ public void handleLikeCreated(LikeCreatedEvent event) {
 
     @Async
     @TransactionalEventListener(phase = AFTER_COMMIT)
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void handleLikeDeleted(LikeDeletedEvent event) {
         try {
             productRepository.findByIdForUpdate(event.productId())

apps/commerce-api/src/main/java/com/loopers/application/payment/PaymentEventHandler.java

@@ -8,6 +8,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.event.TransactionalEventListener;
 
@@ -25,7 +26,7 @@ public class PaymentEventHandler {
      */
     @TransactionalEventListener(phase = AFTER_COMMIT)
     @Async("eventTaskExecutor")
-    @Transactional
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void handlePaymentSuccess(PaymentSuccessEvent event) {
         log.info("결제 성공 이벤트 처리 시작 - orderId: {}", event.orderId());
         try {
@@ -50,7 +51,7 @@ public void handlePaymentSuccess(PaymentSuccessEvent event) {
      */
     @TransactionalEventListener(phase = AFTER_COMMIT)
     @Async("eventTaskExecutor")
-    @Transactional
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void handlePaymentFailed(PaymentFailedEvent event) {
         log.info("결제 실패 이벤트 처리 시작 - orderId: {}, reason: {}", event.orderId(), event.failureReason());
         try {

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

@@ -2,24 +2,35 @@
 
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.infrastructure.rank.MonthlyRankJpaRepository;
+import com.loopers.infrastructure.rank.WeeklyRankJpaRepository;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.redis.core.ZSetOperations;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
 
 @Component
 @RequiredArgsConstructor
 public class RankingFacade {
 
     private final RankingService rankingService;
     private final ProductRepository productRepository;
+    private final WeeklyRankJpaRepository weeklyRankJpaRepository;
+    private final MonthlyRankJpaRepository monthlyRankJpaRepository;
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
 
     @Transactional(readOnly = true)
     public List<RankingProductInfo> getDailyRanking(String yyyymmdd, int page, int size) {
@@ -48,27 +59,101 @@ public List<RankingProductInfo> getDailyRanking(String yyyymmdd, int page, int s
             productMap.put(pdt.getId(), pdt);
         }
 
+        int baseRank = (int) start + 1;
+        AtomicInteger rankCounter = new AtomicInteger(baseRank);
         for (ZSetOperations.TypedTuple<String> t : tuples) {
             String member = t.getValue();
             if (member == null || member.isBlank()) continue;
             Long productId = Long.valueOf(member);
             Product product = productMap.get(productId);
             if (product == null) continue;
-            result.add(toInfo(productId, product));
+            int rank = rankCounter.getAndIncrement();
+            Double score = t.getScore();
+            result.add(toInfo(productId, product, rank, score));
         }
         return result;
     }
 
-    private RankingProductInfo toInfo(Long productId, Product product) {
+    @Transactional(readOnly = true)
+    public List<RankingProductInfo> getWeeklyRanking(String weekStartYyyymmdd, int page, int size) {
+        int p = Math.max(1, page);
+        int s = Math.max(1, size);
+        LocalDate periodStart = LocalDate.parse(weekStartYyyymmdd, DATE_FORMATTER);
+
+        var rows = weeklyRankJpaRepository.findByPeriodStartOrderByRankPositionAsc(
+                periodStart, PageRequest.of(p - 1, s)
+        );
+        return buildRanking(
+                rows,
+                r -> r.getProductId(),
+                r -> r.getRankPosition() != null ? r.getRankPosition() : 0,
+                r -> r.getTotalScore()
+        );
+    }
+
+    @Transactional(readOnly = true)
+    public List<RankingProductInfo> getMonthlyRanking(String monthStartYyyymmdd, int page, int size) {
+        int p = Math.max(1, page);
+        int s = Math.max(1, size);
+        LocalDate periodStart = LocalDate.parse(monthStartYyyymmdd, DATE_FORMATTER);
+
+        var rows = monthlyRankJpaRepository.findByPeriodStartOrderByRankPositionAsc(
+                periodStart, PageRequest.of(p - 1, s)
+        );
+        return buildRanking(
+                rows,
+                r -> r.getProductId(),
+                r -> r.getRankPosition() != null ? r.getRankPosition() : 0,
+                r -> r.getTotalScore()
+        );
+    }
+
+    private RankingProductInfo toInfo(Long productId, Product product, int rank, Double score) {
         return new RankingProductInfo(
+                rank,
+                score,
                 productId,
                 product.getName(),
                 product.getPrice() != null ? product.getPrice().getAmount() : BigDecimal.ZERO,
+                product.getStockQuantity(),
                 product.getLikeCount() != null ? product.getLikeCount() : 0L
         );
     }
 
-
+    private <T> List<RankingProductInfo> buildRanking(
+            List<T> rows,
+            Function<T, Long> productIdExtractor,
+            ToIntFunction<T> rankExtractor,
+            Function<T, Double> scoreExtractor
+    ) {
+        if (rows == null || rows.isEmpty()) {
+            return List.of();
+        }
+        List<Long> productIds = rows.stream()
+                .map(productIdExtractor)
+                .toList();
+
+        List<Product> products = productRepository.findByIdIn(productIds);
+        Map<Long, Product> productMap = new HashMap<>();
+        for (Product prd : products) {
+            productMap.put(prd.getId(), prd);
+        }
+
+        List<RankingProductInfo> result = new ArrayList<>();
+        for (T row : rows) {
+            Long productId = productIdExtractor.apply(row);
+            Product product = productMap.get(productId);
+            if (product == null) {
+                continue;
+            }
+            int rank = rankExtractor.applyAsInt(row);
+            Double score = scoreExtractor.apply(row);
+            result.add(toInfo(productId, product, rank, score));
+        }
+        return result;
+    }
+
+
 }
 
 

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

@@ -3,9 +3,12 @@
 import java.math.BigDecimal;
 
 public record RankingProductInfo(
+        int rank,
+        Double score,
         Long productId,
         String name,
         BigDecimal price,
+        Integer stock,
         Long likeCount
 ) {}
 

apps/commerce-api/src/main/java/com/loopers/config/AsyncConfig.java

@@ -0,0 +1,29 @@
+package com.loopers.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ThreadPoolExecutor;
+
+@Configuration
+public class AsyncConfig {
+
+	@Bean(name = "eventTaskExecutor")
+	public Executor eventTaskExecutor() {
+		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+		executor.setCorePoolSize(4);
+		executor.setMaxPoolSize(16);
+		executor.setQueueCapacity(1000);
+		executor.setKeepAliveSeconds(60);
+		executor.setThreadNamePrefix("event-async-");
+		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+		executor.setWaitForTasksToCompleteOnShutdown(true);
+		executor.setAwaitTerminationSeconds(10);
+		executor.initialize();
+		return executor;
+	}
+}
+
+

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

@@ -0,0 +1,59 @@
+package com.loopers.domain.rank;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Immutable;
+
+@Entity
+@Table(name = "mv_product_rank_monthly")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Immutable
+public class MonthlyProductRankView {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(name = "product_id", nullable = false)
+	private Long productId;
+
+	@Column(name = "period_start", nullable = false)
+	private LocalDate periodStart;
+
+	@Column(name = "rank_position", nullable = false)
+	private Integer rankPosition;
+
+	@Column(name = "total_score", nullable = false)
+	private Double totalScore;
+
+	@Column(name = "like_count", nullable = false)
+	private Integer likeCount;
+
+	@Column(name = "view_count", nullable = false)
+	private Integer viewCount;
+
+	@Column(name = "order_count", nullable = false)
+	private Integer orderCount;
+
+	@Column(name = "sales_amount", nullable = false, precision = 15, scale = 2)
+	private BigDecimal salesAmount;
+
+	@Column(name = "created_at", nullable = false, updatable = false)
+	private LocalDateTime createdAt;
+
+	@Column(name = "updated_at", nullable = false)
+	private LocalDateTime updatedAt;
+}
+
+

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

@@ -0,0 +1,59 @@
+package com.loopers.domain.rank;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Immutable;
+
+@Entity
+@Table(name = "mv_product_rank_weekly")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Immutable
+public class WeeklyProductRankView {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(name = "product_id", nullable = false)
+	private Long productId;
+
+	@Column(name = "period_start", nullable = false)
+	private LocalDate periodStart;
+
+	@Column(name = "rank_position", nullable = false)
+	private Integer rankPosition;
+
+	@Column(name = "total_score", nullable = false)
+	private Double totalScore;
+
+	@Column(name = "like_count", nullable = false)
+	private Integer likeCount;
+
+	@Column(name = "view_count", nullable = false)
+	private Integer viewCount;
+
+	@Column(name = "order_count", nullable = false)
+	private Integer orderCount;
+
+	@Column(name = "sales_amount", nullable = false, precision = 15, scale = 2)
+	private BigDecimal salesAmount;
+
+	@Column(name = "created_at", nullable = false, updatable = false)
+	private LocalDateTime createdAt;
+
+	@Column(name = "updated_at", nullable = false)
+	private LocalDateTime updatedAt;
+}
+
+

apps/commerce-api/src/main/java/com/loopers/infrastructure/rank/MonthlyRankJpaRepository.java

@@ -0,0 +1,15 @@
+package com.loopers.infrastructure.rank;
+
+import com.loopers.domain.rank.MonthlyProductRankView;
+import java.time.LocalDate;
+import java.util.List;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface MonthlyRankJpaRepository extends JpaRepository<MonthlyProductRankView, Long> {
+	List<MonthlyProductRankView> findByPeriodStartOrderByRankPositionAsc(LocalDate periodStart, Pageable pageable);
+}
+
+