Feature/ranking exception

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

@@ -5,19 +5,19 @@
 import com.loopers.domain.brand.Brand;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductDetail;
-import com.loopers.support.error.CoreException;
-import com.loopers.support.error.ErrorType;
 import com.loopers.zset.ZSetEntry;
 import com.loopers.zset.RedisZSetTemplate;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.dao.DataAccessException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 /**
@@ -45,12 +45,20 @@ public class RankingService {
     private final RankingKeyGenerator keyGenerator;
     private final ProductService productService;
     private final BrandService brandService;
+    private final RankingSnapshotService rankingSnapshotService;
 
     /**
      * 랭킹을 조회합니다 (페이징).
      * <p>
      * ZSET에서 상위 N개를 조회하고, 상품 정보를 Aggregation하여 반환합니다.
      * </p>
+     * <p>
+     * <b>Graceful Degradation:</b>
+     * <ul>
+     *   <li>Redis 장애 시 스냅샷으로 Fallback</li>
+     *   <li>스냅샷도 없으면 기본 랭킹(좋아요순) 제공 (단순 조회, 계산 아님)</li>
+     * </ul>
+     * </p>
      *
      * @param date 날짜 (yyyyMMdd 형식의 문자열 또는 LocalDate)
      * @param page 페이지 번호 (0부터 시작)
@@ -59,6 +67,47 @@ public class RankingService {
      */
     @Transactional(readOnly = true)
     public RankingsResponse getRankings(LocalDate date, int page, int size) {
+        try {
+            return getRankingsFromRedis(date, page, size);
+        } catch (DataAccessException e) {
+            log.warn("Redis 랭킹 조회 실패, 스냅샷으로 Fallback: date={}, error={}", 
+                date, e.getMessage());
+            // 스냅샷으로 Fallback 시도
+            Optional<RankingsResponse> snapshot = rankingSnapshotService.getSnapshot(date);
+            if (snapshot.isPresent()) {
+                log.info("스냅샷으로 랭킹 제공: date={}, itemCount={}", date, snapshot.get().items().size());
+                return snapshot.get();
+            }
+
+            // 전날 스냅샷 시도
+            Optional<RankingsResponse> yesterdaySnapshot = rankingSnapshotService.getSnapshot(date.minusDays(1));
+            if (yesterdaySnapshot.isPresent()) {
+                log.info("전날 스냅샷으로 랭킹 제공: date={}, itemCount={}", date, yesterdaySnapshot.get().items().size());
+                return yesterdaySnapshot.get();
+            }
+
+            // 최종 Fallback: 기본 랭킹 (단순 조회, 계산 아님)
+            log.warn("스냅샷도 없음, 기본 랭킹(좋아요순)으로 Fallback: date={}", date);
+            return getDefaultRankings(page, size);
+        } catch (Exception e) {
+            log.error("랭킹 조회 중 예상치 못한 오류 발생, 기본 랭킹으로 Fallback: date={}", date, e);
+            return getDefaultRankings(page, size);
+        }
+    }
+
+    /**
+     * Redis에서 랭킹을 조회합니다.
+     * <p>
+     * 스케줄러에서 스냅샷 저장 시 호출하기 위해 public으로 제공합니다.
+     * </p>
+     *
+     * @param date 날짜
+     * @param page 페이지 번호
+     * @param size 페이지당 항목 수
+     * @return 랭킹 조회 결과
+     * @throws DataAccessException Redis 접근 실패 시
+     */
+    public RankingsResponse getRankingsFromRedis(LocalDate date, int page, int size) {
         String key = keyGenerator.generateDailyKey(date);
         long start = (long) page * size;
         long end = start + size - 1;
@@ -132,18 +181,118 @@ public RankingsResponse getRankings(LocalDate date, int page, int size) {
         return new RankingsResponse(rankingItems, page, size, hasNext);
     }
 
+    /**
+     * 기본 랭킹(좋아요순)을 제공합니다.
+     * <p>
+     * 최종 Fallback으로 사용됩니다. 랭킹을 새로 계산하는 것이 아니라
+     * 이미 집계된 좋아요 수를 단순 조회하는 것이므로 DB 부하가 크지 않습니다.
+     * </p>
+     *
+     * @param page 페이지 번호 (0부터 시작)
+     * @param size 페이지당 항목 수
+     * @return 랭킹 조회 결과
+     */
+    private RankingsResponse getDefaultRankings(int page, int size) {
+        // 좋아요순으로 상품 조회
+        List<Product> products = productService.findAll(null, "likes_desc", page, size);
+        long totalCount = productService.countAll(null);
+
+        if (products.isEmpty()) {
+            return RankingsResponse.empty(page, size);
+        }
+
+        // 브랜드 ID 수집
+        List<Long> brandIds = products.stream()
+            .map(Product::getBrandId)
+            .distinct()
+            .toList();
+
+        // 브랜드 배치 조회
+        Map<Long, Brand> brandMap = brandService.getBrands(brandIds).stream()
+            .collect(Collectors.toMap(Brand::getId, brand -> brand));
+
+        // 랭킹 항목 생성 (좋아요 수를 점수로 사용)
+        List<RankingItem> rankingItems = new ArrayList<>();
+        long start = (long) page * size;
+        for (int i = 0; i < products.size(); i++) {
+            Product product = products.get(i);
+            Long rank = start + i + 1; // 1-based 순위
+
+            Brand brand = brandMap.get(product.getBrandId());
+            if (brand == null) {
+                log.warn("상품의 브랜드를 찾을 수 없습니다: productId={}, brandId={}", 
+                    product.getId(), product.getBrandId());
+                continue;
+            }
+
+            ProductDetail productDetail = ProductDetail.from(
+                product, 
+                brand.getName(), 
+                product.getLikeCount()
+            );
+
+            // 좋아요 수를 점수로 사용
+            double score = product.getLikeCount() != null ? product.getLikeCount().doubleValue() : 0.0;
+            rankingItems.add(new RankingItem(
+                rank,
+                score,
+                productDetail
+            ));
+        }
+
+        boolean hasNext = (start + size) < totalCount;
+        return new RankingsResponse(rankingItems, page, size, hasNext);
+    }
+
     /**
      * 특정 상품의 순위를 조회합니다.
      * <p>
      * 상품이 랭킹에 없으면 null을 반환합니다.
      * </p>
+     * <p>
+     * <b>Graceful Degradation:</b>
+     * <ul>
+     *   <li>Redis 장애 시 전날 랭킹으로 Fallback</li>
+     *   <li>전날 랭킹도 없으면 null 반환 (기본 랭킹에서는 순위 계산 불가)</li>
+     * </ul>
+     * </p>
      *
      * @param productId 상품 ID
      * @param date 날짜
      * @return 순위 (1부터 시작, 없으면 null)
      */
     @Transactional(readOnly = true)
     public Long getProductRank(Long productId, LocalDate date) {
+        try {
+            return getProductRankFromRedis(productId, date);
+        } catch (DataAccessException e) {
+            log.warn("Redis 상품 순위 조회 실패, 전날 랭킹으로 Fallback: productId={}, date={}, error={}", 
+                productId, date, e.getMessage());
+            // 전날 랭킹으로 Fallback 시도
+            try {
+                LocalDate yesterday = date.minusDays(1);
+                return getProductRankFromRedis(productId, yesterday);
+            } catch (DataAccessException fallbackException) {
+                log.warn("전날 랭킹 조회도 실패: productId={}, date={}, error={}", 
+                    productId, date, fallbackException.getMessage());
+                // 기본 랭킹에서는 순위 계산이 어려우므로 null 반환
+                return null;
+            }
+        } catch (Exception e) {
+            log.error("상품 순위 조회 중 예상치 못한 오류 발생: productId={}, date={}", productId, date, e);
+            return null;
+        }
+    }
+
+    /**
+     * Redis에서 상품 순위를 조회합니다.
+     *
+     * @param productId 상품 ID
+     * @param date 날짜
+     * @return 순위 (1부터 시작, 없으면 null)
+     * @throws DataAccessException Redis 접근 실패 시
+     */
+    private Long getProductRankFromRedis(Long productId, LocalDate date) {
         String key = keyGenerator.generateDailyKey(date);
         Long rank = zSetTemplate.getRank(key, String.valueOf(productId));
 

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

@@ -0,0 +1,103 @@
+package com.loopers.application.ranking;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 랭킹 스냅샷 서비스.
+ * <p>
+ * Redis 장애 시 Fallback으로 사용하기 위한 랭킹 데이터 스냅샷을 인메모리에 저장합니다.
+ * </p>
+ * <p>
+ * <b>설계 원칙:</b>
+ * <ul>
+ *   <li>인메모리 캐시: 구현이 간단하고 성능이 우수함</li>
+ *   <li>메모리 관리: 최근 7일치만 보관하여 메모리 사용량 제한</li>
+ *   <li>스냅샷 기반 Fallback: DB 실시간 재계산 대신 스냅샷 서빙으로 DB 부하 방지</li>
+ * </ul>
+ * </p>
+ *
+ * @author Loopers
+ * @version 1.0
+ */
+@Slf4j
+@Service
+public class RankingSnapshotService {
+
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private static final int MAX_SNAPSHOTS = 7; // 최근 7일치만 보관
+
+    private final Map<String, RankingService.RankingsResponse> snapshotCache = new ConcurrentHashMap<>();
+
+    /**
+     * 랭킹 스냅샷을 저장합니다.
+     *
+     * @param date 날짜
+     * @param rankings 랭킹 조회 결과
+     */
+    public void saveSnapshot(LocalDate date, RankingService.RankingsResponse rankings) {
+        String key = date.format(DATE_FORMATTER);
+        snapshotCache.put(key, rankings);
+        log.debug("랭킹 스냅샷 저장: date={}, key={}, itemCount={}", date, key, rankings.items().size());
+
+        // 오래된 스냅샷 정리 (메모리 관리)
+        cleanupOldSnapshots();
+    }
+
+    /**
+     * 랭킹 스냅샷을 조회합니다.
+     *
+     * @param date 날짜
+     * @return 랭킹 조회 결과 (없으면 empty)
+     */
+    public Optional<RankingService.RankingsResponse> getSnapshot(LocalDate date) {
+        String key = date.format(DATE_FORMATTER);
+        RankingService.RankingsResponse snapshot = snapshotCache.get(key);
+
+        if (snapshot != null) {
+            log.debug("랭킹 스냅샷 조회 성공: date={}, key={}, itemCount={}", date, key, snapshot.items().size());
+            return Optional.of(snapshot);
+        }
+
+        log.debug("랭킹 스냅샷 없음: date={}, key={}", date, key);
+        return Optional.empty();
+    }
+
+    /**
+     * 오래된 스냅샷을 정리합니다.
+     * <p>
+     * 최근 7일치만 보관하여 메모리 사용량을 제한합니다.
+     * </p>
+     */
+    private void cleanupOldSnapshots() {
+        if (snapshotCache.size() <= MAX_SNAPSHOTS) {
+            return;
+        }
+
+        // 가장 오래된 스냅샷 제거
+        LocalDate today = LocalDate.now(ZoneId.of("UTC"));
+        LocalDate oldestDate = today.minusDays(MAX_SNAPSHOTS);
+
+        snapshotCache.entrySet().removeIf(entry -> {
+            try {
+                LocalDate entryDate = LocalDate.parse(entry.getKey(), DATE_FORMATTER);
+                boolean shouldRemove = entryDate.isBefore(oldestDate);
+                if (shouldRemove) {
+                    log.debug("오래된 스냅샷 제거: key={}", entry.getKey());
+                }
+                return shouldRemove;
+            } catch (Exception e) {
+                log.warn("스냅샷 키 파싱 실패, 제거: key={}", entry.getKey(), e);
+                return true; // 파싱 실패한 키는 제거
+            }
+        });
+    }
+}
+

apps/commerce-api/src/main/java/com/loopers/infrastructure/scheduler/RankingSnapshotScheduler.java

@@ -0,0 +1,72 @@
+package com.loopers.infrastructure.scheduler;
+
+import com.loopers.application.ranking.RankingService;
+import com.loopers.application.ranking.RankingSnapshotService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+
+/**
+ * 랭킹 스냅샷 저장 스케줄러.
+ * <p>
+ * 주기적으로 랭킹 결과를 스냅샷으로 저장하여, Redis 장애 시 Fallback으로 사용할 수 있도록 합니다.
+ * </p>
+ * <p>
+ * <b>설계 원칙:</b>
+ * <ul>
+ *   <li>스냅샷 기반 Fallback: DB 실시간 재계산 대신 스냅샷 서빙으로 DB 부하 방지</li>
+ *   <li>주기적 저장: 1시간마다 최신 랭킹을 스냅샷으로 저장</li>
+ *   <li>에러 처리: 스냅샷 저장 실패 시에도 다음 스케줄에서 재시도</li>
+ * </ul>
+ * </p>
+ * <p>
+ * <b>주기 선택 근거:</b>
+ * <ul>
+ *   <li>비용 대비 효과: 1시간 주기가 리소스 사용량이 1/12로 감소하면서도 사용자 체감 차이는 거의 없음</li>
+ *   <li>랭킹의 성격: 비즈니스 결정이 아닌 조회용 파생 데이터이므로 1시간 전 데이터도 충분히 유용함</li>
+ *   <li>운영 관점: 스케줄러 실행 빈도가 낮아 모니터링 부담 감소</li>
+ * </ul>
+ * </p>
+ *
+ * @author Loopers
+ * @version 1.0
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class RankingSnapshotScheduler {
+
+    private final RankingService rankingService;
+    private final RankingSnapshotService rankingSnapshotService;
+
+    /**
+     * 랭킹 스냅샷을 저장합니다.
+     * <p>
+     * 1시간마다 실행되어 오늘의 랭킹을 스냅샷으로 저장합니다.
+     * </p>
+     */
+    @Scheduled(fixedRate = 3600000) // 1시간마다 (3600000ms = 1시간)
+    public void saveRankingSnapshot() {
+        LocalDate today = LocalDate.now(ZoneId.of("UTC"));
+        try {
+            // 상위 100개 랭킹을 스냅샷으로 저장 (대부분의 사용자가 상위 100개 이내만 조회)
+            // Redis가 정상일 때만 스냅샷 저장 (예외 발생 시 스킵)
+            RankingService.RankingsResponse rankings = rankingService.getRankingsFromRedis(today, 0, 100);
+
+            rankingSnapshotService.saveSnapshot(today, rankings);
+
+            log.debug("랭킹 스냅샷 저장 완료: date={}, itemCount={}", today, rankings.items().size());
+        } catch (org.springframework.dao.DataAccessException e) {
+            log.warn("Redis 장애로 인한 랭킹 스냅샷 저장 실패: date={}, error={}", today, e.getMessage());
+            // Redis 장애 시 스냅샷 저장 스킵 (다음 스케줄에서 재시도)
+        } catch (Exception e) {
+            log.warn("랭킹 스냅샷 저장 실패: date={}", today, e);
+            // 스냅샷 저장 실패는 다음 스케줄에서 재시도
+        }
+    }
+}
+