[volume-9] Product Ranking with Redis

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

@@ -17,6 +17,8 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
 import java.util.List;
 
 @Component
@@ -25,6 +27,7 @@ public class ProductFacade {
     private final ProductRepository productRepository;
     private final BrandRepository brandRepository;
     private final OutboxRepository outBoxRepository;
+    private final RankingRedisReader rankingRedisReader;
 
     @Transactional
     public ProductInfo registerProduct(ProductV1Dto.ProductRequest request) {
@@ -52,7 +55,7 @@ public List<ProductInfo> findAllProducts() {
 
     @Transactional
     @Cacheable(value = "product", key = "#id")
-    public ProductInfo findProductById(Long id) {
+    public ProductRankingInfo findProductById(Long id) {
         Product product = productRepository.findById(id).orElseThrow(
                 () -> new CoreException(ErrorType.NOT_FOUND, "찾고자 하는 상품이 존재하지 않습니다.")
         );
@@ -65,7 +68,14 @@ public ProductInfo findProductById(Long id) {
 
         outBoxRepository.save(outBoxEvent);
 
-        return ProductInfo.from(product);
+        RankingInfo ranking = null;
+
+        try {
+            String date = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
+            ranking = rankingRedisReader.getDailyRanking(date, product.getId());
+        } catch (Exception ignored) {}
+
+        return ProductRankingInfo.from(product, ranking);
     }
 
     @Transactional(readOnly = true)

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

@@ -0,0 +1,20 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.product.Product;
+
+import java.math.BigDecimal;
+
+public record ProductRankingInfo(Long id, Long brandId, String name, BigDecimal price, int stock, int likeCount, int rank, double score) {
+    public static ProductRankingInfo from(Product product, RankingInfo ranking) {
+        return new ProductRankingInfo(
+                product.getId(),
+                product.getBrandId(),
+                product.getName(),
+                product.getPrice(),
+                product.getStock(),
+                product.getLikeCount(),
+                ranking.rank(),
+                ranking.score()
+        );
+    }
+}

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

@@ -0,0 +1,9 @@
+package com.loopers.application.product;
+
+public record RankingInfo(
+        String date,
+        double score,
+        int rank,
+        Long total
+) {
+}

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

@@ -0,0 +1,40 @@
+package com.loopers.application.product;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class RankingRedisReader {
+    private final StringRedisTemplate redisTemplate;
+
+    public RankingInfo getDailyRanking(String date, Long productId) {
+        String key = "ranking:all:" + date;
+        String member = String.valueOf(productId);
+
+        RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
+        byte[] keyBytes = serializer.serialize(key);
+        byte[] memberBytes = serializer.serialize(member);
+
+        @SuppressWarnings("unchecked")
+        List<Object> results = (List<Object>) redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
+            connection.zScore(keyBytes, memberBytes);   // -> Double (or null)
+            connection.zRevRank(keyBytes, memberBytes); // -> Long   (or null) 0-base
+            connection.zCard(keyBytes);                 // -> Long
+            return null;
+        });
+
+        Double score = (Double) results.get(0);
+        Long revRank0 = (Long) results.get(1);
+        Long total = (Long) results.get(2);
+
+        Integer rank = (revRank0 == null) ? null : Math.toIntExact(revRank0 + 1);
+
+        return new RankingInfo(date, score, rank, total);
+    }
+}

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

@@ -15,7 +15,7 @@ public interface ProductV1ApiSpec {
     ApiResponse<List<ProductV1Dto.ProductResponse>> findAllProducts();
 
     @Operation(summary = "상품 상세 조회")
-    ApiResponse<ProductV1Dto.ProductResponse> findProductById(Long id);
+    ApiResponse<ProductV1Dto.ProductRankingResponse> findProductById(Long id);
 
     @Operation(summary = "상품 정렬 조회")
     ApiResponse<List<ProductV1Dto.ProductResponse>> findProductsBySortCondition(ProductV1Dto.SearchProductRequest request);

apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java

@@ -2,6 +2,7 @@
 
 import com.loopers.application.product.ProductFacade;
 import com.loopers.application.product.ProductInfo;
+import com.loopers.application.product.ProductRankingInfo;
 import com.loopers.interfaces.api.ApiResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -42,9 +43,9 @@ public ApiResponse<List<ProductV1Dto.ProductResponse>> findAllProducts() {
 
     @GetMapping("/{id}")
     @Override
-    public ApiResponse<ProductV1Dto.ProductResponse> findProductById(@PathVariable Long id) {
-        ProductInfo info = productFacade.findProductById(id);
-        ProductV1Dto.ProductResponse response = ProductV1Dto.ProductResponse.from(info);
+    public ApiResponse<ProductV1Dto.ProductRankingResponse> findProductById(@PathVariable Long id) {
+        ProductRankingInfo info = productFacade.findProductById(id);
+        ProductV1Dto.ProductRankingResponse response = ProductV1Dto.ProductRankingResponse.from(info);
 
         return ApiResponse.success(response);
     }

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

@@ -1,13 +1,27 @@
 package com.loopers.interfaces.api.product;
 
 import com.loopers.application.product.ProductInfo;
+import com.loopers.application.product.ProductRankingInfo;
 import com.loopers.domain.product.Product;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 
 import java.math.BigDecimal;
 
 public class ProductV1Dto {
+    public record ProductRankingResponse(Long id, Long brandId, String name, BigDecimal price, int stock, int rank, double score) {
+        public static ProductRankingResponse from(ProductRankingInfo info) {
+            return new ProductRankingResponse(
+                    info.id(),
+                    info.brandId(),
+                    info.name(),
+                    info.price(),
+                    info.stock(),
+                    info.rank(),
+                    info.score()
+            );
+        }
+    }
     public record ProductResponse(Long id, Long brandId, String name, BigDecimal price, int stock, int likeCount) {
         public static ProductResponse from(ProductInfo info) {
             return new ProductResponse(

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

@@ -0,0 +1,70 @@
+package com.loopers.application;
+
+import com.loopers.interfaces.api.ranking.RankingV1Dto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.redis.core.ZSetOperations;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+@Component
+@RequiredArgsConstructor
+public class RankingFacade {
+    private final StringRedisTemplate redisTemplate;
+    private static final ZoneId KST = ZoneId.of("Asia/Seoul");
+    private static final DateTimeFormatter YYYYMMDD = DateTimeFormatter.BASIC_ISO_DATE;
+
+    public RankingV1Dto.ProductRankingPageResponse getDailyProductRanking(int page, int size) {
+        if (page < 1) page = 1;
+        if (size < 1) size = 20;
+
+        String date = LocalDate.now(KST).format(YYYYMMDD);
+
+        String key = "ranking:all:" + date;
+        ZSetOperations<String, String> zset = redisTemplate.opsForZSet();
+
+        Long total = zset.size(key);
+        long totalElements = (total == null) ? 0 : total;
+
+        if (totalElements == 0) {
+            return new RankingV1Dto.ProductRankingPageResponse(date, page, size, 0, 0, List.of());
+        }
+
+        long start = (long) (page - 1) * size;
+        long end = start + size - 1;
+
+        if (start >= totalElements) {
+            int totalPages = (int) Math.ceil((double) totalElements / size);
+            return new RankingV1Dto.ProductRankingPageResponse(date, page, size, totalElements, totalPages, List.of());
+        }
+
+        Set<ZSetOperations.TypedTuple<String>> tuples =
+                zset.reverseRangeWithScores(key, start, end);
+
+        List<RankingV1Dto.ProductRankingResponse> items = new ArrayList<>();
+        if (tuples != null) {
+            long rank = start + 1;
+            for (var t : tuples) {
+                String member = t.getValue();
+                Double score = t.getScore();
+                if (member == null || score == null) continue;
+
+                items.add(new RankingV1Dto.ProductRankingResponse(
+                        rank++,
+                        Long.parseLong(member),
+                        score
+                ));
+            }
+        }
+
+        int totalPages = (int) Math.ceil((double) totalElements / size);
+        return new RankingV1Dto.ProductRankingPageResponse(date, page, size, totalElements, totalPages, items);
+    }
+
+}

apps/commerce-streamer/src/main/java/com/loopers/interfaces/api/ApiControllerAdvice.java

@@ -0,0 +1,126 @@
+package com.loopers.interfaces.api;
+
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.exc.InvalidFormatException;
+import com.fasterxml.jackson.databind.exc.MismatchedInputException;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+import org.springframework.web.server.ServerWebInputException;
+import org.springframework.web.servlet.resource.NoResourceFoundException;
+
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+@RestControllerAdvice
+@Slf4j
+public class ApiControllerAdvice {
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handle(CoreException e) {
+        log.warn("CoreException : {}", e.getCustomMessage() != null ? e.getCustomMessage() : e.getMessage(), e);
+        return failureResponse(e.getErrorType(), e.getCustomMessage());
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleBadRequest(MethodArgumentTypeMismatchException e) {
+        String name = e.getName();
+        String type = e.getRequiredType() != null ? e.getRequiredType().getSimpleName() : "unknown";
+        String value = e.getValue() != null ? e.getValue().toString() : "null";
+        String message = String.format("요청 파라미터 '%s' (타입: %s)의 값 '%s'이(가) 잘못되었습니다.", name, type, value);
+        return failureResponse(ErrorType.BAD_REQUEST, message);
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleBadRequest(MissingServletRequestParameterException e) {
+        String name = e.getParameterName();
+        String type = e.getParameterType();
+        String message = String.format("필수 요청 파라미터 '%s' (타입: %s)가 누락되었습니다.", name, type);
+        return failureResponse(ErrorType.BAD_REQUEST, message);
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleBadRequest(HttpMessageNotReadableException e) {
+        String errorMessage;
+        Throwable rootCause = e.getRootCause();
+
+        if (rootCause instanceof InvalidFormatException invalidFormat) {
+            String fieldName = invalidFormat.getPath().stream()
+                .map(ref -> ref.getFieldName() != null ? ref.getFieldName() : "?")
+                .collect(Collectors.joining("."));
+
+            String valueIndicationMessage = "";
+            if (invalidFormat.getTargetType().isEnum()) {
+                Class<?> enumClass = invalidFormat.getTargetType();
+                String enumValues = Arrays.stream(enumClass.getEnumConstants())
+                    .map(Object::toString)
+                    .collect(Collectors.joining(", "));
+                valueIndicationMessage = "사용 가능한 값 : [" + enumValues + "]";
+            }
+
+            String expectedType = invalidFormat.getTargetType().getSimpleName();
+            Object value = invalidFormat.getValue();
+
+            errorMessage = String.format("필드 '%s'의 값 '%s'이(가) 예상 타입(%s)과 일치하지 않습니다. %s",
+                fieldName, value, expectedType, valueIndicationMessage);
+
+        } else if (rootCause instanceof MismatchedInputException mismatchedInput) {
+            String fieldPath = mismatchedInput.getPath().stream()
+                .map(ref -> ref.getFieldName() != null ? ref.getFieldName() : "?")
+                .collect(Collectors.joining("."));
+            errorMessage = String.format("필수 필드 '%s'이(가) 누락되었습니다.", fieldPath);
+
+        } else if (rootCause instanceof JsonMappingException jsonMapping) {
+            String fieldPath = jsonMapping.getPath().stream()
+                .map(ref -> ref.getFieldName() != null ? ref.getFieldName() : "?")
+                .collect(Collectors.joining("."));
+            errorMessage = String.format("필드 '%s'에서 JSON 매핑 오류가 발생했습니다: %s",
+                fieldPath, jsonMapping.getOriginalMessage());
+
+        } else {
+            errorMessage = "요청 본문을 처리하는 중 오류가 발생했습니다. JSON 메세지 규격을 확인해주세요.";
+        }
+
+        return failureResponse(ErrorType.BAD_REQUEST, errorMessage);
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleBadRequest(ServerWebInputException e) {
+        String missingParams = extractMissingParameter(e.getReason() != null ? e.getReason() : "");
+        if (!missingParams.isEmpty()) {
+            String message = String.format("필수 요청 값 '%s'가 누락되었습니다.", missingParams);
+            return failureResponse(ErrorType.BAD_REQUEST, message);
+        } else {
+            return failureResponse(ErrorType.BAD_REQUEST, null);
+        }
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleNotFound(NoResourceFoundException e) {
+        return failureResponse(ErrorType.NOT_FOUND, null);
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handle(Throwable e) {
+        log.error("Exception : {}", e.getMessage(), e);
+        return failureResponse(ErrorType.INTERNAL_ERROR, null);
+    }
+
+    private String extractMissingParameter(String message) {
+        Pattern pattern = Pattern.compile("'(.+?)'");
+        Matcher matcher = pattern.matcher(message);
+        return matcher.find() ? matcher.group(1) : "";
+    }
+
+    private ResponseEntity<ApiResponse<?>> failureResponse(ErrorType errorType, String errorMessage) {
+        return ResponseEntity.status(errorType.getStatus())
+            .body(ApiResponse.fail(errorType.getCode(), errorMessage != null ? errorMessage : errorType.getMessage()));
+    }
+}