[volume-9] Product Ranking with Redis

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

@@ -0,0 +1,18 @@
+package com.loopers.application.api.product;
+
+import com.loopers.core.service.productlike.ProductLikeEventPublishService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class ProductLikeEventScheduler {
+
+    private final ProductLikeEventPublishService service;
+
+    @Scheduled(fixedDelay = 1000)
+    public void publish() {
+        service.publish();
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.loopers.application.api.product;
+
+import com.loopers.core.service.product.ProductRankingCarryOverService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class ProductRankingCarryOverScheduler {
+
+    private final ProductRankingCarryOverService service;
+
+    @Scheduled(cron = "0 50 23 * * *")
+    public void carryOver() {
+        service.carryOver();
+    }
+}

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

@@ -4,21 +4,30 @@
 import com.loopers.core.domain.product.Product;
 import com.loopers.core.domain.product.ProductDetail;
 import com.loopers.core.domain.product.ProductListView;
+import com.loopers.core.domain.product.ProductRankingList;
+import com.loopers.core.service.product.GetProductRankingService;
 import com.loopers.core.service.product.ProductQueryService;
 import com.loopers.core.service.product.query.GetProductDetailQuery;
 import com.loopers.core.service.product.query.GetProductListQuery;
 import com.loopers.core.service.product.query.GetProductQuery;
+import com.loopers.core.service.product.query.GetProductRankingQuery;
 import lombok.RequiredArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.*;
 
+import java.time.LocalDate;
+
 import static com.loopers.application.api.product.ProductV1Dto.*;
+import static com.loopers.application.api.product.ProductV1Dto.GetProductDetailResponse.GetProductRankingsResponse;
+import static com.loopers.application.api.product.ProductV1Dto.GetProductDetailResponse.from;
 
 @RestController
 @RequiredArgsConstructor
 @RequestMapping("/api/v1/products")
 public class ProductV1Api implements ProductV1ApiSpec {
 
     private final ProductQueryService queryService;
+    private final GetProductRankingService getProductRankingService;
 
     @Override
     @GetMapping("/{productId}")
@@ -50,6 +59,18 @@ public ApiResponse<GetProductDetailResponse> getProductDetail(
     ) {
         ProductDetail productDetail = queryService.getProductDetail(new GetProductDetailQuery(productId));
 
-        return ApiResponse.success(GetProductDetailResponse.from(productDetail));
+        return ApiResponse.success(from(productDetail));
+    }
+
+    @Override
+    @GetMapping("/rankings")
+    public ApiResponse<GetProductRankingsResponse> getProductRankings(
+            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date,
+            @RequestParam(required = false, defaultValue = "0") int pageNo,
+            @RequestParam(required = false, defaultValue = "10") int pageSize
+    ) {
+        ProductRankingList ranking = getProductRankingService.getRanking(new GetProductRankingQuery(date, pageNo, pageSize));
+
+        return ApiResponse.success(GetProductRankingsResponse.from(ranking));
     }
 }

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

@@ -4,20 +4,25 @@
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 
+import java.time.LocalDate;
+
+import static com.loopers.application.api.product.ProductV1Dto.*;
+import static com.loopers.application.api.product.ProductV1Dto.GetProductDetailResponse.GetProductRankingsResponse;
+
 @Tag(name = "Product V1 API", description = "상품 API 입니다.")
 public interface ProductV1ApiSpec {
 
     @Operation(
             summary = "상품 정보 조회",
             description = "상품 정보를 조회합니다."
     )
-    ApiResponse<ProductV1Dto.GetProductResponse> getProduct(String productId);
+    ApiResponse<GetProductResponse> getProduct(String productId);
 
     @Operation(
             summary = "상품 목록 조회",
             description = "상품 목록을 조회합니다."
     )
-    ApiResponse<ProductV1Dto.GetProductListResponse> getProductList(
+    ApiResponse<GetProductListResponse> getProductList(
             String brandId,
             String createdAtSort,
             String priceSort,
@@ -30,5 +35,11 @@ ApiResponse<ProductV1Dto.GetProductListResponse> getProductList(
             summary = "상품 상세 조회",
             description = "상품 상세 정보를 조회합니다."
     )
-    ApiResponse<ProductV1Dto.GetProductDetailResponse> getProductDetail(String productId);
+    ApiResponse<GetProductDetailResponse> getProductDetail(String productId);
+
+    @Operation(
+            summary = "상품 랭킹 조회",
+            description = "상품 랭킹을 조회합니다."
+    )
+    ApiResponse<GetProductRankingsResponse> getProductRankings(LocalDate date, int pageNo, int pageSize);
 }

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

@@ -1,13 +1,13 @@
 package com.loopers.application.api.product;
 
 import com.loopers.core.domain.brand.Brand;
-import com.loopers.core.domain.product.Product;
-import com.loopers.core.domain.product.ProductDetail;
-import com.loopers.core.domain.product.ProductListItem;
-import com.loopers.core.domain.product.ProductListView;
+import com.loopers.core.domain.product.*;
+import com.loopers.core.domain.product.ProductRankingList.ProductRankingItem;
+import com.loopers.core.domain.product.vo.ProductRanking;
 
 import java.math.BigDecimal;
 import java.util.List;
+import java.util.Optional;
 
 public class ProductV1Dto {
 
@@ -77,7 +77,8 @@ public record GetProductDetailResponse(
             String name,
             BigDecimal price,
             Long stock,
-            Long likeCount
+            Long likeCount,
+            GetProductDetailRanking ranking
     ) {
 
         public static GetProductDetailResponse from(ProductDetail detail) {
@@ -87,10 +88,22 @@ public static GetProductDetailResponse from(ProductDetail detail) {
                     detail.getProduct().getName().value(),
                     detail.getProduct().getPrice().value(),
                     detail.getProduct().getStock().value(),
-                    detail.getProduct().getLikeCount().value()
+                    detail.getProduct().getLikeCount().value(),
+                    Optional.ofNullable(detail.getRanking())
+                            .map(GetProductDetailRanking::from)
+                            .orElse(null)
             );
         }
 
+        public record GetProductDetailRanking(
+                Long ranking,
+                Double score
+        ) {
+            public static GetProductDetailRanking from(ProductRanking ranking) {
+                return new GetProductDetailRanking(ranking.ranking(), ranking.score());
+            }
+        }
+
         public record GetProductDetailBrand(
                 String id,
                 String name,
@@ -105,5 +118,48 @@ public static GetProductDetailBrand from(Brand brand) {
                 );
             }
         }
+
+        public record GetProductRankingsResponse(
+                List<ProductRankingResponse> products,
+                long totalElements,
+                int totalPages,
+                boolean hasNext,
+                boolean hasPrevious
+        ) {
+
+            public static GetProductRankingsResponse from(ProductRankingList list) {
+                return new GetProductRankingsResponse(
+                        list.products().stream()
+                                .map(ProductRankingResponse::from)
+                                .toList(),
+                        list.totalElements(),
+                        list.totalPages(),
+                        list.hasNext(),
+                        list.hasPrevious()
+                );
+            }
+
+            public record ProductRankingResponse(
+                    String id,
+                    Long ranking,
+                    String brandName,
+                    String name,
+                    BigDecimal price,
+                    Long likeCount,
+                    Double score
+            ) {
+                public static ProductRankingResponse from(ProductRankingItem item) {
+                    return new ProductRankingResponse(
+                            item.id().value(),
+                            item.ranking(),
+                            item.brandName().value(),
+                            item.name().value(),
+                            item.price().value(),
+                            item.likeCount().value(),
+                            item.score()
+                    );
+                }
+            }
+        }
     }
 }

apps/commerce-api/src/main/resources/application.yml

@@ -30,6 +30,16 @@ spring:
       product-detail-viewed: product-detail-viewed.v1
       product-out-of-stock: product-out-of-stock.v1
       payment-completed: payment-completed.v1
+      product-like: product-like.v1
+
+product:
+  ranking:
+    score:
+      weight:
+        like: 0.2
+        view: 0.1
+        pay: 0.7
+        carryOver: 0.1
 
 springdoc:
   use-fqn: true

apps/commerce-api/src/test/java/com/loopers/application/api/product/ProductV1ApiIntegrationTest.java

@@ -7,6 +7,7 @@
 import com.loopers.core.domain.brand.repository.BrandRepository;
 import com.loopers.core.domain.product.Product;
 import com.loopers.core.domain.product.ProductFixture;
+import com.loopers.core.domain.product.repository.ProductRankingCacheRepository;
 import com.loopers.core.domain.product.repository.ProductRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -19,6 +20,9 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 
+import java.time.LocalDate;
+
+import static com.loopers.application.api.product.ProductV1Dto.GetProductDetailResponse.GetProductRankingsResponse;
 import static com.loopers.application.api.product.ProductV1Dto.GetProductListResponse;
 import static com.loopers.application.api.product.ProductV1Dto.GetProductResponse;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -31,6 +35,9 @@ class ProductV1ApiIntegrationTest extends ApiIntegrationTest {
     @Autowired
     private ProductRepository productRepository;
 
+    @Autowired
+    private ProductRankingCacheRepository productRankingCacheRepository;
+
     @Nested
     @DisplayName("상품 목록 조회")
     class 상품_목록_조회 {
@@ -136,4 +143,74 @@ void status404() {
             }
         }
     }
+
+    @Nested
+    @DisplayName("상품 랭킹 조회")
+    class 상품_랭킹_조회 {
+
+        @Nested
+        @DisplayName("정상 요청인 경우")
+        class 정상_요청인_경우 {
+
+            @BeforeEach
+            void setUp() {
+                Brand brand = brandRepository.save(
+                        BrandFixture.create()
+                );
+
+                Product product1 = productRepository.save(
+                        ProductFixture.createWith(brand.getId())
+                );
+                productRankingCacheRepository.increaseDaily(product1.getId(), LocalDate.now(), 0.7);
+
+                Product product2 = productRepository.save(
+                        ProductFixture.createWith(brand.getId())
+                );
+                productRankingCacheRepository.increaseDaily(product2.getId(), LocalDate.now(), 0.9);
+            }
+
+            @Test
+            @DisplayName("Status 200")
+            void status200() {
+                // When
+                LocalDate today = LocalDate.now();
+                String endPoint = "/api/v1/products/rankings?date=" + today + "&pageNo=0&pageSize=10";
+
+                ParameterizedTypeReference<ApiResponse<GetProductRankingsResponse>> responseType =
+                        new ParameterizedTypeReference<>() {
+                        };
+
+                ResponseEntity<ApiResponse<GetProductRankingsResponse>> response =
+                        testRestTemplate.exchange(endPoint, HttpMethod.GET, HttpEntity.EMPTY, responseType);
+
+                // Then
+                assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+                assertThat(response.getBody()).isNotNull();
+                assertThat(response.getBody().data()).isNotNull();
+                assertThat(response.getBody().data().products()).isNotEmpty();
+            }
+
+            @Test
+            @DisplayName("페이지네이션 정보가 포함되어 있다")
+            void pagination_information_included() {
+                // When
+                LocalDate today = LocalDate.now();
+                String endPoint = "/api/v1/products/rankings?date=" + today + "&pageNo=0&pageSize=10";
+
+                ParameterizedTypeReference<ApiResponse<GetProductRankingsResponse>> responseType =
+                        new ParameterizedTypeReference<>() {
+                        };
+
+                ResponseEntity<ApiResponse<GetProductRankingsResponse>> response =
+                        testRestTemplate.exchange(endPoint, HttpMethod.GET, HttpEntity.EMPTY, responseType);
+
+                // Then
+                GetProductRankingsResponse rankingResponse = response.getBody().data();
+                assertThat(rankingResponse.totalElements()).isGreaterThanOrEqualTo(0);
+                assertThat(rankingResponse.totalPages()).isGreaterThanOrEqualTo(0);
+                assertThat(rankingResponse.hasNext()).isFalse();
+                assertThat(rankingResponse.hasPrevious()).isFalse();
+            }
+        }
+    }
 }

apps/commerce-streamer/src/main/java/com/loopers/applications/streamer/consumer/product/IncreaseProductLikeRankingScoreKafkaConsumer.java

@@ -0,0 +1,36 @@
+package com.loopers.applications.streamer.consumer.product;
+
+import com.loopers.JacksonUtil;
+import com.loopers.applications.streamer.consumer.product.dto.IncreaseProductLikeRankingScoreEvent;
+import com.loopers.core.infra.event.kafka.config.KafkaConfig;
+import com.loopers.core.service.productlike.IncreaseProductLikeRankingScoreService;
+import lombok.RequiredArgsConstructor;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.Acknowledgment;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class IncreaseProductLikeRankingScoreKafkaConsumer {
+
+    private final IncreaseProductLikeRankingScoreService service;
+
+    @KafkaListener(
+            topics = {"${spring.kafka.topic.product-like}"},
+            containerFactory = KafkaConfig.BATCH_LISTENER,
+            groupId = "increase-product-like-ranking-score"
+    )
+    public void listen(
+            List<ConsumerRecord<Object, String>> records,
+            Acknowledgment acknowledgment
+    ) {
+        records.stream()
+                .map(event -> JacksonUtil.convertToObject(event.value(), IncreaseProductLikeRankingScoreEvent.class))
+                .map(IncreaseProductLikeRankingScoreEvent::toCommand)
+                .forEach(service::increase);
+        acknowledgment.acknowledge();
+    }
+}