[volume-9] Product Ranking with Redis

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

@@ -1,12 +1,12 @@
 package com.loopers.application.like;
 
-import com.loopers.application.like.event.LikeCanceledEvent;
-import com.loopers.application.like.event.LikeCreatedEvent;
 import com.loopers.domain.like.Like;
 import com.loopers.domain.like.LikeService;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductLikeCountService;
 import com.loopers.domain.product.ProductService;
+import com.loopers.messaging.event.LikeCanceledEvent;
+import com.loopers.messaging.event.LikeCreatedEvent;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;

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

@@ -4,6 +4,8 @@
 import com.loopers.domain.common.event.DomainEventEnvelop;
 import com.loopers.domain.common.event.DomainEventRepository;
 import com.loopers.domain.product.ProductLikeCountService;
+import com.loopers.messaging.event.LikeCanceledEvent;
+import com.loopers.messaging.event.LikeCreatedEvent;
 import com.loopers.support.json.JsonConverter;
 import lombok.RequiredArgsConstructor;
 import org.springframework.scheduling.annotation.Async;

apps/commerce-api/src/main/java/com/loopers/application/order/event/OrderEventHandler.java

@@ -3,10 +3,10 @@
 import com.loopers.application.order.OrderExternalSystemSender;
 import com.loopers.application.order.OrderFacade;
 import com.loopers.application.payment.event.PaymentFailedEvent;
-import com.loopers.application.payment.event.PaymentSucceededEvent;
 import com.loopers.domain.common.event.DomainEvent;
 import com.loopers.domain.common.event.DomainEventEnvelop;
 import com.loopers.domain.common.event.DomainEventRepository;
+import com.loopers.messaging.event.OrderPaidEvent;
 import com.loopers.support.json.JsonConverter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -31,8 +31,8 @@ public class OrderEventHandler {
 
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public void handle(PaymentSucceededEvent event) {
-        log.info("🔥 PaymentSucceededEvent handler 진입");
+    public void handle(OrderPaidEvent event) {
+        log.info("🔥 OrderPaidEvent handler 진입");
         orderFacade.handleOrderSucceed(event.orderId());
     }
 
@@ -48,7 +48,7 @@ public void handle(PaymentFailedEvent event) {
      */
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     @Async
-    void handleOrderCreatedExternalSend(PaymentSucceededEvent event) {
+    void handleOrderCreatedExternalSend(OrderPaidEvent event) {
         try {
             orderExternalSystemSender.send(event.orderId());
         } catch (Exception e) {
@@ -61,9 +61,9 @@ void handleOrderCreatedExternalSend(PaymentSucceededEvent event) {
      * 결제 성공 시, outbox 테이블에 이벤트를 저장합니다.
      */
     @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
-    public void handleOutboxEvent(PaymentSucceededEvent event) {
+    public void handleOutboxEvent(OrderPaidEvent event) {
 
-        DomainEventEnvelop<PaymentSucceededEvent> envelop =
+        DomainEventEnvelop<OrderPaidEvent> envelop =
                 DomainEventEnvelop.of(
                         "ORDER_PAID",
                         "ORDER",

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

@@ -1,14 +1,14 @@
 package com.loopers.application.payment;
 
 import com.loopers.application.order.event.OrderCreated;
-import com.loopers.application.payment.event.PaymentSucceededEvent;
 import com.loopers.domain.order.Order;
 import com.loopers.domain.order.OrderService;
 import com.loopers.domain.payment.Payment;
 import com.loopers.domain.payment.PaymentService;
 import com.loopers.domain.point.PointService;
 import com.loopers.infrastructure.ResilientPgClient;
 import com.loopers.interfaces.api.payment.PaymentV1Dto;
+import com.loopers.messaging.event.OrderPaidEvent;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -17,6 +17,8 @@
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+
 @Slf4j
 @Component
 @RequiredArgsConstructor
@@ -51,7 +53,16 @@ public void pay(Long userId, Long orderId) {
            case POINT -> {
                try {
                    pointService.usePoint(payment.getUserId(), payment.getAmount());
-                   eventPublisher.publishEvent(PaymentSucceededEvent.from(orderId));
+
+                   List<OrderPaidEvent.OrderItemData> items =
+                           order.getItems().stream()
+                                           .map(item -> new OrderPaidEvent.OrderItemData(
+                                                   item.getProductId(),
+                                                   item.getQuantity(),
+                                                   item.getTotalPrice().getAmount()
+                                           )).toList();
+
+                   eventPublisher.publishEvent(OrderPaidEvent.of(orderId, items));
                } catch (IllegalArgumentException e) {
                    throw new CoreException(ErrorType.BAD_REQUEST, e.getMessage());
                }

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

@@ -1,19 +1,26 @@
 package com.loopers.application.payment;
 
 import com.loopers.application.payment.event.PaymentFailedEvent;
-import com.loopers.application.payment.event.PaymentSucceededEvent;
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderService;
+import com.loopers.messaging.event.OrderPaidEvent;
+import com.loopers.messaging.event.OrderPaidEvent.OrderItemData;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 @Slf4j
 @Component
 @RequiredArgsConstructor
 public class PaymentProcessService {
 
     private final PaymentFacade paymentFacade;
+    private final OrderService orderService; // Added OrderService injection
 
     private final ApplicationEventPublisher eventPublisher;
 
@@ -28,12 +35,19 @@ public void process(Long userId, Long orderId) {
     }
 
     @Transactional
-    public void processPg(Long userId, Long orderId) {
+    public void processPg(Long userId, Long orderId) { // Added userId parameter
         try {
             paymentFacade.payPg(orderId);
-            eventPublisher.publishEvent(PaymentSucceededEvent.from(orderId));
+
+            Order order = orderService.findOrderById(orderId)
+                    .orElseThrow(() -> new IllegalStateException("결제된 주문 정보를 찾을 수 없습니다. orderId: " + orderId));
+
+            List<OrderItemData> orderItemDataList = order.getItems().stream()
+                    .map(item -> new OrderItemData(item.getProductId(), item.getQuantity(), item.getUnitPrice().getAmount()))
+                    .collect(Collectors.toList());
+
+            eventPublisher.publishEvent(OrderPaidEvent.of(orderId, orderItemDataList));
         } catch (Exception e) {
-            // 이외 서버 타임아웃 등은 retry -> pending상태로 스케줄링 시도
             log.error("외부 PG 결제 실패, 주문 ID: {}", orderId, e);
             eventPublisher.publishEvent(PaymentFailedEvent.of(userId, orderId, e));
         }

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

@@ -10,16 +10,18 @@ public record ProductDetailInfo(
         Long brandId,
         String brandName,
         BigDecimal priceAmount,
-        int likeCount
+        int likeCount,
+        Long rank
 ) {
-    public static ProductDetailInfo from(ProductDetailProjection p) {
+    public static ProductDetailInfo of(ProductDetailProjection p, Long rank) {
         return new ProductDetailInfo(
                 p.getProductId(),
                 p.getProductName(),
                 p.getBrandId(),
                 p.getBrandName(),
                 p.getPrice().getAmount(),
-                p.getLikeCount()
+                p.getLikeCount(),
+                rank
         );
     }
 }

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

@@ -1,10 +1,11 @@
 package com.loopers.application.product;
 
 import com.fasterxml.jackson.core.type.TypeReference;
-import com.loopers.application.product.event.ProductViewedEvent;
 import com.loopers.cache.CacheKeyService;
 import com.loopers.cache.CacheService;
 import com.loopers.domain.product.ProductService;
+import com.loopers.domain.ranking.RankingService;
+import com.loopers.messaging.event.ProductViewedEvent;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.ApplicationEventPublisher;
@@ -14,6 +15,7 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.Duration;
+import java.time.LocalDate;
 
 @RequiredArgsConstructor
 @Component
@@ -26,6 +28,7 @@ public class ProductFacade {
     private final ProductQueryService productQueryService;
     private final ApplicationEventPublisher eventPublisher;
 
+    private final RankingService rankingService;
 
     private static final Duration TTL_LIST = Duration.ofMinutes(10);
     private static final Duration TTL_DETAIL = Duration.ofMinutes(5);
@@ -55,9 +58,11 @@ private Page<ProductInfo> loadProducts(Long brandId, Pageable pageable, String s
     public ProductDetailInfo getProductDetail(Long productId) {
         String key = "product:v1:detail:" + productId;
 
+        Long rank = rankingService.getRanking(LocalDate.now(), productId);
+
         ProductDetailInfo productDetailInfo = cacheService.getOrLoad(
                 key,
-                () -> productService.getProductDetail(productId),
+                () -> ProductDetailInfo.of(productService.getProductDetail(productId), rank),
                 TTL_DETAIL,
                 ProductDetailInfo.class);
 

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

@@ -0,0 +1,42 @@
+package com.loopers.application.product.event;
+
+import com.loopers.domain.common.event.DomainEvent;
+import com.loopers.domain.common.event.DomainEventEnvelop;
+import com.loopers.domain.common.event.DomainEventRepository;
+import com.loopers.messaging.event.ProductViewedEvent;
+import com.loopers.support.json.JsonConverter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ProductViewedEventHandler {
+
+    private final DomainEventRepository eventRepository;
+    private final JsonConverter jsonConverter;
+
+    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
+    public void handleProductViewedEvent(ProductViewedEvent event) {
+        log.info("ProductViewedEvent received: productId={}, occurredAt={}", event.productId(), event.occurredAt());
+
+        DomainEventEnvelop<ProductViewedEvent> envelop =
+                DomainEventEnvelop.of(
+                        "PRODUCT_VIEWED",
+                        "PRODUCT",
+                        event.productId(),
+                        event
+                );
+
+        eventRepository.save(
+                DomainEvent.pending(
+                        "catalog-events",
+                        envelop,
+                        jsonConverter.serialize(envelop)
+                )
+        );
+    }
+}

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

@@ -0,0 +1,82 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductLikeCountService;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.ranking.RankingService;
+import com.loopers.interfaces.api.ranking.RankingV1Dto.RankingProductResponse;
+import com.loopers.ranking.streamer.RankingInfo;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class RankingFacade {
+    private final RankingService rankingService;
+    private final ProductService productService;
+    private final ProductLikeCountService productLikeCountService;
+
+    public Page<RankingProductResponse> getRankings(LocalDate rankingDate, Pageable pageable) {
+
+        // 1. Redis ZSET에서 랭킹 상품 ID와 점수를 조회
+        List<RankingInfo> rankedProducts = rankingService.getRankings(rankingDate, pageable);
+        long totalCount = rankingService.getTotalCount(rankingDate);
+
+        // 2. 랭킹 상품 ID들을 추출
+        List<Long> productIds = rankedProducts.stream()
+                .map(RankingInfo::id)
+                .toList();
+
+        // 3. ProductService 통해 상품 상세 정보 조회 (상품 ID 순서 유지를 위해 Map 사용)
+        Map<Long, Product> productInfos = productService.getProductsMapByIds(productIds);
+
+        // 4. 조회된 상품 정보와 랭킹 데이터를 결합하여 응답 DTO 생성
+        List<RankingProductResponse> rankingResponses = rankedProducts.stream()
+                .map(ranking -> {
+                    Product product = productInfos.get(ranking.id());
+
+                    if (product == null) {
+                        log.warn("상품 정보를 찾을 수 없습니다. 상품ID : {}", ranking.id());
+                        return null;
+                    }
+
+                    // 좋아요 수를 ProductLikeCountService에서 조회 (없으면 0)
+                    int likeCount = productLikeCountService.findById(product.getId())
+                            .map(pc -> pc.getLikeCount())
+                            .orElse(0);
+
+                    return new RankingProductResponse(
+                            product.getId(),
+                            product.getName(),
+                            product.getBrandId(),
+                            product.getPrice().getAmount(),
+                            likeCount,
+                            ranking.score(),
+                            ranking.rank(),
+                            LocalDateTime.now()     // createdAt?
+                    );
+                })
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+
+        Page<RankingProductResponse> responsePage = new PageImpl<>(
+                rankingResponses,
+                pageable,
+                totalCount
+        );
+
+        return responsePage;
+    };
+}