[refactor] 게시글 좋아요 api 서버 처리율 개선 - 레디스 비동기 큐잉 적용

loadtest/feed/feed-like-load-test.js

@@ -0,0 +1,161 @@
+// feed-like-load-test.js
+import http from 'k6/http';
+import { sleep,check } from 'k6';
+import { Trend, Counter } from 'k6/metrics';
+
+const BASE_URL = 'http://localhost:8080';
+const FEED_ID = 1; // 테스트할 피드 ID
+const USERS_START   = 1;   // 토큰 발급 시작 userId
+const USERS_COUNT   = 5000;     // 총 사용자 = VU 수
+const TOKEN_BATCH   = 200;     // 토큰 발급 배치 크기
+const BATCH_PAUSE_S = 0.2;     // 배치 간 대기 (for 토큰 발급 API 병목 방지)
+const START_DELAY_S = 5;       // 테스트 시작 전 대기 (for 방 참여 요청 동시 시작)
+
+// ===== 커스텀 메트릭 =====
+const likeLatency = new Trend('feed_like_latency'); // 참여 API 지연(ms)
+const http5xx     = new Counter('feed_like_5xx');   // 5xx 개수
+const http2xx     = new Counter('feed_like_2xx');   // 2xx 개수
+const http4xx     = new Counter('feed_like_4xx');   // 4xx 개수
+
+// 실패 원인 분포 파악용(응답 JSON의 code 필드 기준)
+const token_issue_failed = new Counter('token_issue_failed');
+const fail_POST_ALREADY_LIKED = new Counter('fail_POST_ALREADY_LIKED');
+const fail_POST_NOT_LIKED_CANNOT_CANCEL = new Counter('fail_POST_NOT_LIKED_CANNOT_CANCEL');
+const fail_POST_LIKE_COUNT_UNDERFLOW     = new Counter('fail_POST_LIKE_COUNT_UNDERFLOW');
+const fail_OTHER_4XX                    = new Counter('fail_OTHER_4XX');
+
+const ERR = {   // THIP error code
+    POST_ALREADY_LIKED: 185001,
+    POST_NOT_LIKED_CANNOT_CANCEL: 185002,
+    POST_LIKE_COUNT_UNDERFLOW: 185000
+};
+
+function parseError(res) {
+    try {
+        const j = JSON.parse(res.body || '{}'); // BaseResponse 구조
+        return {
+            code: Number(j.code),              // 정수 코드
+            message: j.message || '',
+            requestId: j.requestId || '',
+            isSuccess: !!j.isSuccess
+        };
+    } catch (e) {
+        return { code: NaN, message: '', requestId: '', isSuccess: false };
+    }
+}
+
+// ------------ 시나리오 ------------
+// 특정 시점에 한 게시물 (인기 작가,인플루언서가 작성한)에 좋아요 요청이 몰리는 상황 가정
+export let options = {
+    scenarios: {
+        // 각 VU가 "정확히 1회" 실행 → 1 VU = 1명 유저
+        feed_like_once: {
+            executor: 'per-vu-iterations',
+            vus: USERS_COUNT,
+            iterations: 1,
+            startTime: '0s',         // 모든 VU가 거의 동시에 스케줄링
+            gracefulStop: '5s',
+        },
+    },
+    thresholds: {
+        feed_like_5xx:     ['count==0'],     // 서버 오류는 0건이어야 함
+        feed_like_latency: ['p(95)<500'],   // p95 < 500ms
+    },
+};
+
+// 테스트 전 사용자 별 토큰 배치 발급
+export function setup() {
+    const userIds = Array.from({ length: USERS_COUNT }, (_, i) => USERS_START + i);
+    const tokens = [];
+
+    for (let i = 0; i < userIds.length; i += TOKEN_BATCH) {
+        const slice = userIds.slice(i, i + TOKEN_BATCH);
+        const reqs = slice.map((uid) => [
+            'GET',
+            `${BASE_URL}/api/test/token/access?userId=${uid}`,
+            null,
+            { tags: { phase: 'setup_token_issue', feed: `${FEED_ID}` } },
+        ]);
+
+        const responses = http.batch(reqs);
+        for (const r of responses) {
+            if (r.status === 200 && r.body) {
+                tokens.push(r.body.trim());
+            }
+            else {
+                tokens.push(''); // 실패한 자리도 인덱스 유지
+                token_issue_failed.add(1);
+            }
+        }
+        sleep(BATCH_PAUSE_S);
+    }
+    if (tokens.length > USERS_COUNT) tokens.length = USERS_COUNT;
+
+    const startAt = Date.now() + START_DELAY_S * 1000;    // 동시 시작 시간
+
+    return { tokens, startAt };
+}
+
+// VU : 각자 자기 토큰으로 참여 호출 & 각자 1회만 실행
+export default function (data) {
+    const vuIdx = __VU - 1;
+    const token = data.tokens[vuIdx];
+
+    // 동기 시작: startAt까지 대기 → 모든 VU가 거의 같은 타이밍에 시작
+    const now = Date.now();
+    if (now < data.startAt) {
+        sleep((data.startAt - now) / 1000);
+    }
+
+    if (!token) {     // 토큰 발급 실패 -> 스킵
+        return;
+    }
+
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+    };
+
+    // 동시에 모든 유저가 인기 게시물에 대해 좋아요 요청
+    const body = JSON.stringify({ type: 'true' });
+    const url = `${BASE_URL}/feeds/${FEED_ID}/likes`;
+
+    const res = http.post(url, body, { headers, tags: { phase: 'like', feed: `${FEED_ID}` } });
+
+    // === 커스텀 메트릭 기록 ===
+    likeLatency.add(res.timings.duration);
+    if (res.status >= 200 && res.status < 300) http2xx.add(1);
+    else if (res.status >= 400 && res.status < 500) {
+        http4xx.add(1);
+        const err = parseError(res);
+        switch (err.code) {
+            case ERR.POST_ALREADY_LIKED:
+                fail_POST_ALREADY_LIKED.add(1);
+                break;
+            case ERR.POST_NOT_LIKED_CANNOT_CANCEL:
+                fail_POST_NOT_LIKED_CANNOT_CANCEL.add(1);
+                break;
+            case ERR.POST_LIKE_COUNT_UNDERFLOW:
+                fail_POST_LIKE_COUNT_UNDERFLOW.add(1);
+                break;
+            default:
+                fail_OTHER_4XX.add(1);
+        }
+    } else if (res.status >= 500) {
+        http5xx.add(1);
+    }
+
+    // === 검증 ===
+    check(res, {
+        'like responded': (r) => r.status !== 0,
+        'like 200 or expected 4xx': (r) => r.status === 200 || (r.status >= 400 && r.status < 500),
+    });
+}
+
+// 테스트 결과 html 리포트로 저장
+import { htmlReport } from "https://raw.githubusercontent.com/benc-uk/k6-reporter/main/dist/bundle.js";
+export function handleSummary(data) {
+    return {
+        "summary.html": htmlReport(data),
+    };
+}

src/main/java/konkuk/thip/config/RedisConfig.java

@@ -8,6 +8,7 @@
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.GenericToStringSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 @Configuration
@@ -29,6 +30,16 @@ public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connec
         return redisTemplate;
     }
 
+    @Bean
+    public RedisTemplate<String, Integer> redisIntegerTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<String, Integer> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(connectionFactory);
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setValueSerializer(new GenericToStringSerializer<>(Integer.class));
+        return redisTemplate;
+    }
+
+
     @Bean
     public RedisConnectionFactory redisConnectionFactory() {
         return new LettuceConnectionFactory(host, port);

src/main/java/konkuk/thip/config/WorkerThreadConfig.java

@@ -13,7 +13,7 @@
 import java.util.concurrent.ThreadPoolExecutor;
 
 @Configuration
-@EnableAsync
+@EnableAsync(proxyTargetClass = true)
 @Profile("!test")
 public class WorkerThreadConfig implements AsyncConfigurer {
 
@@ -54,6 +54,23 @@ public Executor schedulerAsyncExecutor() {
         return executor;
     }
 
+    /**
+     * PostLike 이벤트 전용 실행기
+     * - 좋아요/취소 시 Redis Set/Count 갱신 및 큐 발행 처리
+     * - 순간적인 높은 트래픽에 대비하여 큐 용량 확보
+     */
+    @Bean(name = "postLikeAsyncExecutor")
+    public Executor postLikeAsyncExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(5);
+        executor.setMaxPoolSize(30);
+        executor.setQueueCapacity(300);
+        executor.setThreadNamePrefix("like-async-");
+        executor.setWaitForTasksToCompleteOnShutdown(true);
+        executor.initialize();
+        return executor;
+    }
+
     @Override
     public Executor getAsyncExecutor() {
         return fcmAsyncExecutor(); // 기본은 FCM 풀 사용

src/main/java/konkuk/thip/feed/adapter/out/persistence/FeedCommandPersistenceAdapter.java

@@ -1,5 +1,9 @@
 package konkuk.thip.feed.adapter.out.persistence;
 
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Map;
 import konkuk.thip.book.adapter.out.jpa.BookJpaEntity;
 import konkuk.thip.book.adapter.out.persistence.repository.BookJpaRepository;
 import konkuk.thip.comment.adapter.out.persistence.repository.CommentJpaRepository;
@@ -16,6 +20,8 @@
 import konkuk.thip.user.adapter.out.jpa.UserJpaEntity;
 import konkuk.thip.user.adapter.out.persistence.repository.UserJpaRepository;
 import lombok.RequiredArgsConstructor;
+import org.springframework.jdbc.core.BatchPreparedStatementSetter;
+import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -27,6 +33,8 @@
 @RequiredArgsConstructor
 public class FeedCommandPersistenceAdapter implements FeedCommandPort {
 
+    private final JdbcTemplate jdbcTemplate;
+
     private final FeedJpaRepository feedJpaRepository;
     private final UserJpaRepository userJpaRepository;
     private final BookJpaRepository bookJpaRepository;
@@ -44,6 +52,13 @@ public Optional<Feed> findById(Long id) {
                 .map(feedMapper::toDomainEntity);
     }
 
+    @Override
+    public List<Long> findByIds(List<Long> ids) {
+        if (ids == null || ids.isEmpty())
+            return new ArrayList<>();
+        return feedJpaRepository.findByPostIds(ids);
+    }
+
 
     @Override
     public Long save(Feed feed) {
@@ -114,6 +129,26 @@ public void deleteAllFeedByUserId(Long userId) {
         feedJpaRepository.softDeleteAllByUserId(userId);
     }
 
+    @Override
+    public void batchUpdateLikeCounts(Map<Long, Integer> idToLikeCount) {
+        String sql = "UPDATE posts SET like_count = like_count + ? WHERE post_id = ?";
+        List<Map.Entry<Long, Integer>> entries = new ArrayList<>(idToLikeCount.entrySet());
+
+        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
+            @Override
+            public void setValues(PreparedStatement ps, int i) throws SQLException {
+                Map.Entry<Long, Integer> entry = entries.get(i);
+                ps.setInt(1, entry.getValue());  // Redis에서 가져온 좋아요 수 (증분 값)
+                ps.setLong(2, entry.getKey());   //게시글 ID
+            }
+
+            @Override
+            public int getBatchSize() {
+                return entries.size();
+            }
+        });
+    }
+
     @Override
     public void delete(Feed feed) {
         FeedJpaEntity feedJpaEntity = feedJpaRepository.findByPostId(feed.getId())

src/main/java/konkuk/thip/feed/adapter/out/persistence/repository/FeedJpaRepository.java

@@ -29,4 +29,6 @@ public interface FeedJpaRepository extends JpaRepository<FeedJpaEntity, Long>, F
     @Query("UPDATE FeedJpaEntity f SET f.status = 'INACTIVE' WHERE f.userJpaEntity.userId = :userId")
     void softDeleteAllByUserId(@Param("userId") Long userId);
 
+    @Query("SELECT f.postId FROM FeedJpaEntity f WHERE f.postId IN :postIds")
+    List<Long> findByPostIds(@Param("postIds") List<Long> postIds);
 }

src/main/java/konkuk/thip/feed/application/port/out/FeedCommandPort.java

@@ -1,6 +1,8 @@
 package konkuk.thip.feed.application.port.out;
 
 
+import java.util.List;
+import java.util.Map;
 import konkuk.thip.common.exception.EntityNotFoundException;
 import konkuk.thip.feed.domain.Feed;
 
@@ -12,6 +14,7 @@ public interface FeedCommandPort {
     Long save(Feed feed);
     Long update(Feed feed);
     Optional<Feed> findById(Long id);
+    List<Long> findByIds(List<Long> ids);
     default Feed getByIdOrThrow(Long id) {
         return findById(id)
                 .orElseThrow(() -> new EntityNotFoundException(FEED_NOT_FOUND));
@@ -21,4 +24,5 @@ default Feed getByIdOrThrow(Long id) {
     void deleteSavedFeed(Long userId, Long feedId);
     void deleteAllSavedFeedByUserId(Long userId);
     void deleteAllFeedByUserId(Long userId);
+    void batchUpdateLikeCounts(Map<Long, Integer> idToLikeCount);
 }

src/main/java/konkuk/thip/feed/domain/Feed.java

@@ -155,8 +155,8 @@ public void decreaseCommentCount() {
     }
 
     @Override
-    public void updateLikeCount(PostCountService postCountService, boolean isLike) {
-        likeCount = postCountService.updatePostLikeCount(isLike, likeCount);
+    public void updateLikeCount(PostCountService postCountService, boolean isLike, int newLikeCount) {
+        likeCount = postCountService.updatePostLikeCount(isLike, newLikeCount);
     }
 
     private void checkCommentCountNotUnderflow() {

src/main/java/konkuk/thip/post/adapter/out/event/PostLikeEventSyncAdapter.java

@@ -0,0 +1,58 @@
+package konkuk.thip.post.adapter.out.event;
+
+import konkuk.thip.post.adapter.out.event.dto.PostLikeChangedEvent;
+import konkuk.thip.post.application.port.out.PostLikeEventCommandPort;
+import konkuk.thip.post.application.port.out.PostLikeQueueCommandPort;
+import konkuk.thip.post.application.port.out.PostLikeRedisCommandPort;
+import konkuk.thip.post.domain.PostType;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class PostLikeEventSyncAdapter implements PostLikeEventCommandPort {
+
+    private final ApplicationEventPublisher publisher;
+
+    private final PostLikeRedisCommandPort postLikeRedisCommandPort;
+    private final PostLikeQueueCommandPort postLikeQueueCommandPort;
+
+    @Override
+    public void publishEvent(Long userId, Long postId, boolean isLike, PostType postType, int finalLikeCount) {
+        publisher.publishEvent(PostLikeChangedEvent.builder()
+                .userId(userId)
+                .postId(postId)
+                .isLike(isLike)
+                .postType(postType)
+                .finalLikeCount(finalLikeCount)
+                .build());
+    }
+
+    @Async("postLikeAsyncExecutor")
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    protected void handlePostLikeChangedEvent(PostLikeChangedEvent event) {
+        // 1. Redis Set 기록 (좋아요 상태 반영)
+        if (event.isLike()) {
+            postLikeRedisCommandPort.addLikeRecordToSet(event.userId(), event.postId());
+        } else {
+            postLikeRedisCommandPort.removeLikeRecordFromSet(event.userId(), event.postId());
+        }
+
+        // 2. Redis 카운트 갱신 (INCR/DECR)
+        postLikeRedisCommandPort.updateLikeCount(event.postType(), event.postId(),
+                event.finalLikeCount(), event.isLike());
+
+        // 3. 비동기 DB 기록 메시지를 큐에 삽입 (Redis List LPUSH)
+        try {
+            postLikeQueueCommandPort.enqueueFromEvent(event);
+        } catch (Exception e) {
+            log.error("CRITICAL: Failed to publish Like Record to Queue. Event Data: {}", event, e);
+        }
+    }
+}