[Refactor] 피드 도메인 캐싱 도입 & 피드 전체 조회 api 캐싱 로직 추가

build.gradle

@@ -104,6 +104,10 @@ dependencies {
 
     // spring Retry
     implementation 'org.springframework.retry:spring-retry'
+
+	// Caffeine Cache
+	implementation 'org.springframework.boot:spring-boot-starter-cache'
+	implementation 'com.github.ben-manes.caffeine:caffeine'
 }
 
 def querydslDir = layout.buildDirectory.dir("generated/querydsl").get().asFile

loadtest/feed/feed_home_scrolling_test.js

@@ -0,0 +1,69 @@
+//100명의 사용자가 동시에 각자 다른 속도로 홈 피드를 1페이지부터 3페이지까지 탐색하는 시나리오
+import http from 'k6/http';
+import { sleep,check } from 'k6';
+
+const BASE_URL = 'http://localhost:8000';
+const MAX_VUS = 500;
+
+export let options = {
+    stages: [
+        { duration: '20s', target: 200 }, // 20초 동안 100명까지 증가
+        { duration: '40s',  target: MAX_VUS }, // 40초 동안 300명까지 증가하며 피크 부하
+        { duration: '20s', target: 0 },   // 20초 동안 0명으로 하강
+    ],
+    thresholds: {
+        http_req_duration: ['p(95)<80'],
+        http_req_failed: ['rate<0.01'],
+    },
+};
+
+// 테스트 전 사용자 별 토큰 발급
+export function setup() {
+    let tokens = [];
+
+    // 유저 ID에 대해 토큰을 미리 발급
+    for (let userId = 1; userId <= MAX_VUS; userId++) {
+        const res = http.get(`${BASE_URL}/api/test/token/access?userId=${userId}`);
+        check(res, { 'token received': (r) => r.status === 200 && r.body.length > 0 });
+        tokens.push(res.body);
+    }
+
+    return { tokens: tokens };
+}
+
+export default function (data) {
+    const vuIdx = __VU - 1;
+    const token = data.tokens[vuIdx];
+
+    const params = {
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+    };
+
+    let currentCursor = null;
+
+    // 모든 유저가 정확히 3번의 요청(1~3페이지) 수행
+    for (let i = 1; i <= 3; i++) {
+        let url = `${BASE_URL}/feeds`;
+        if (currentCursor) {
+            url += `?cursor=${encodeURIComponent(currentCursor)}`;
+        }
+
+        let res = http.get(url, params);
+
+        if (check(res, { 'status is 200': (r) => r.status === 200 })) {
+            const responseData = res.json().data;
+            currentCursor = responseData.nextCursor;
+
+            // 만약 3페이지가 되기 전에 데이터가 끝났다면 루프 탈출
+            if (responseData.isLast || !currentCursor) break;
+        } else {
+            // 요청 실패 시 해당 유저 시나리오 중단
+            break;
+        }
+
+        sleep(Math.random() * 1 + 0.5); // 0.5초 ~ 1.5초 사이 랜덤하게 쉬기
+    }
+}

src/main/java/konkuk/thip/ThipServerApplication.java

@@ -3,9 +3,11 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
+@EnableCaching
 @EnableJpaAuditing
 @EnableScheduling
 @ConfigurationPropertiesScan

src/main/java/konkuk/thip/config/cache/CacheConfig.java

@@ -0,0 +1,45 @@
+package konkuk.thip.config.cache;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.cache.support.SimpleCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class CacheConfig {
+
+    @Bean
+    public CacheManager cacheManager() {
+        SimpleCacheManager cacheManager = new SimpleCacheManager();
+
+        List<CaffeineCache> caches = Arrays.stream(CacheType.values())
+                .map(cacheType -> new CaffeineCache(
+                        cacheType.getCacheName(),
+                        caffeineBuilder(cacheType)
+                ))
+                .collect(Collectors.toList());
+
+        cacheManager.setCaches(caches);
+        return cacheManager;
+    }
+
+    private Cache<Object, Object> caffeineBuilder(CacheType cacheType) {
+        Caffeine<Object, Object> builder = Caffeine.newBuilder()
+                .recordStats()
+                .maximumSize(cacheType.getMaximumSize());
+
+        // 0초 무한유지 설정
+        if (cacheType.getExpireAfterWrite() > 0) {
+            builder.expireAfterWrite(cacheType.getExpireAfterWrite(), TimeUnit.SECONDS);
+        }
+
+        return builder.build();
+    }
+}

src/main/java/konkuk/thip/config/cache/CacheType.java

@@ -0,0 +1,23 @@
+package konkuk.thip.config.cache;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum CacheType {
+    // 최신순 피드 ID 100개 인덱스 캐시
+    FEED_ID_TOP(
+            "feedIdTop",
+            0,  // 만료 시간 없음
+            1), //
+    // 개별 피드 상세 정보를 담는 데이터 캐시
+    FEED_DETAIL(
+            "feedDetail",
+                    0,    // 만료 시간 없음
+                    100);
+
+    private final String cacheName;
+    private final int expireAfterWrite;
+    private final int maximumSize;
+}

src/main/java/konkuk/thip/feed/adapter/in/event/FeedCacheEventListener.java

@@ -0,0 +1,41 @@
+package konkuk.thip.feed.adapter.in.event;
+
+import konkuk.thip.feed.adapter.out.cache.FeedCacheHandler;
+import konkuk.thip.feed.adapter.out.event.dto.FeedCreatedEvent;
+import konkuk.thip.feed.adapter.out.event.dto.FeedDeletedEvent;
+import konkuk.thip.feed.adapter.out.event.dto.FeedUpdatedEvent;
+import konkuk.thip.user.adapter.out.event.dto.UserWithdrawnEvent;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+@RequiredArgsConstructor
+public class FeedCacheEventListener {
+
+    private final FeedCacheHandler feedCacheHandler;
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleFeedCreatedEvent(FeedCreatedEvent event) {
+        feedCacheHandler.updateTopIdsWithNewId(event.feedId());
+        feedCacheHandler.getFeedDetail(event.feedId());
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleFeedDeletedEvent(FeedDeletedEvent event) {
+        feedCacheHandler.markAsDeleted(event.feedId());
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleFeedUpdatedEvent(FeedUpdatedEvent event) {
+        if (feedCacheHandler.evictFeedDetailIfPresent(event.feedId())) {
+            feedCacheHandler.getFeedDetail(event.feedId());
+        }
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void handleUserWithdrawn(UserWithdrawnEvent event) {
+        feedCacheHandler.refreshCacheAfterBulkDelete(event.deletedFeedIds());
+    }
+}

src/main/java/konkuk/thip/feed/adapter/in/event/FeedCacheWarmupListener.java

@@ -0,0 +1,42 @@
+package konkuk.thip.feed.adapter.in.event;
+
+import java.util.List;
+import konkuk.thip.feed.adapter.out.cache.FeedCacheHandler;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Slf4j
+@Component
+@ConditionalOnProperty(
+        name="cache.warmup.enabled",
+        havingValue = "true")
+@RequiredArgsConstructor
+public class FeedCacheWarmupListener {
+
+    private final FeedCacheHandler feedCacheHandler;
+
+    @EventListener(ApplicationReadyEvent.class)
+    @Transactional(readOnly = true)
+    public void handleContextReady() {
+        log.info("애플리케이션 준비 완료: 캐시 워밍업을 시작합니다.");
+
+        try {
+            // 1. 상위 ID 리스트 조회 및 인덱스 캐싱
+            List<Long> topIds = feedCacheHandler.getTopIds();
+            log.info("상위 ID {}개 추출 완료", topIds.size());
+
+            // 2. 상세 데이터 일괄 캐싱
+            if (!topIds.isEmpty()) {
+                feedCacheHandler.warmUpFeedDetails(topIds);
+            }
+            log.info("총 {}개의 피드 상세 데이터 캐시 워밍업 완료", topIds.size());
+        } catch (Exception e) {
+            log.error("캐시 워밍업 중 오류가 발생했습니다: {}", e.getMessage());
+        }
+    }
+}

src/main/java/konkuk/thip/feed/adapter/out/cache/FeedCacheHandler.java

@@ -0,0 +1,123 @@
+package konkuk.thip.feed.adapter.out.cache;
+
+import java.util.ArrayList;
+import java.util.List;
+import konkuk.thip.feed.adapter.out.persistence.repository.FeedJpaRepository;
+import konkuk.thip.feed.application.port.out.dto.FeedQueryDto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class FeedCacheHandler {
+
+    private static final int DEFAULT_CACHE_SIZE = 100;
+
+    private final FeedJpaRepository feedJpaRepository;
+    private final CacheManager cacheManager;
+
+    @Cacheable(cacheNames = "feedIdTop", key = "'top' + " +  DEFAULT_CACHE_SIZE)
+    public List<Long> getTopIds() {
+        return feedJpaRepository.findTopFeedIds(DEFAULT_CACHE_SIZE);
+    }
+
+    @Cacheable(cacheNames = "feedDetail", key = "#feedId")
+    public FeedQueryDto getFeedDetail(Long feedId) {
+        return feedJpaRepository.findFeedDetailById(feedId);
+    }
+
+    @CachePut(cacheNames = "feedDetail", key = "#feedId")
+    public FeedQueryDto markAsDeleted(Long feedId) {
+        return null;
+    }
+
+    public void updateTopIdsWithNewId(Long newId) {
+        Cache cache = cacheManager.getCache("feedIdTop");
+        if (cache == null) return;
+
+        String cacheKey = "top" + DEFAULT_CACHE_SIZE;
+        List<Long> currentIds = cache.get(cacheKey, List.class);
+
+        if (currentIds == null) {
+            currentIds = feedJpaRepository.findTopFeedIds(DEFAULT_CACHE_SIZE);
+        }
+
+        List<Long> updatedIds = new ArrayList<>(currentIds);
+        updatedIds.add(0, newId); // 최신 피드를 맨 앞으로
+
+        if (updatedIds.size() > DEFAULT_CACHE_SIZE) {
+            updatedIds.remove(DEFAULT_CACHE_SIZE);
+        }
+
+        cache.put(cacheKey, updatedIds);
+    }
+
+    public boolean evictFeedDetailIfPresent(Long feedId) {
+        Cache cache = cacheManager.getCache("feedDetail");
+        if (cache == null) return false;
+
+        Cache.ValueWrapper valueWrapper = cache.get(feedId);
+        if (valueWrapper != null) {
+            cache.evict(feedId);
+            return true;
+        }
+        return false;
+    }
+
+    public void warmUpFeedDetails(List<Long> feedIds) {
+        Cache detailCache = cacheManager.getCache("feedDetail");
+        if (detailCache == null || feedIds.isEmpty()) return;
+
+        List<FeedQueryDto> details = feedJpaRepository.findFeedDetailsByIds(feedIds);
+
+        for (FeedQueryDto dto : details) {
+            detailCache.put(dto.feedId(), dto);
+        }
+    }
+
+    public void refreshCacheAfterBulkDelete(List<Long> deletedFeedIds) {
+        Cache cache = cacheManager.getCache("feedIdTop");
+        if (cache == null) return;
+
+        // 1. 현재 캐시된 인덱스 확보
+        String cacheKey = "top" + DEFAULT_CACHE_SIZE;
+        List<Long> currentIds = cache.get(cacheKey, List.class);
+        if (currentIds == null) {
+            return;
+        }
+        // 2. 포함 여부 확인
+        boolean hasTopFeed = deletedFeedIds.stream().anyMatch(currentIds::contains);
+
+        if (hasTopFeed) {
+            // 3. 기존 리스트에서 삭제 대상 제거
+            List<Long> oldIdsWithoutDeleted = new ArrayList<>(currentIds);
+            oldIdsWithoutDeleted.removeAll(deletedFeedIds);
+
+            // 4. 상세 캐시에서 탈퇴자 피드 제거
+            evictFeeds(deletedFeedIds);
+
+            // 5. 인덱스 강제 갱신
+            List<Long> newTopIds = feedJpaRepository.findTopFeedIds(DEFAULT_CACHE_SIZE);
+            cache.put(cacheKey, newTopIds);
+
+            // 6. 신규 진입 ID 추출
+            List<Long> newlyAddedIds = new ArrayList<>(newTopIds);
+            newlyAddedIds.removeAll(oldIdsWithoutDeleted);
+
+            // 7. 신규 진입 피드들만 정밀 워밍업
+            warmUpFeedDetails(newlyAddedIds);
+        }
+    }
+
+    private void evictFeeds(List<Long> feedIds) {
+        Cache cache = cacheManager.getCache("feedDetail");
+        if (cache != null && feedIds != null) {
+            feedIds.forEach(cache::evict);
+        }
+    }
+
+}