[LNK-48] 공감하기 동시성 문제 해결

src/main/java/leets/leenk/domain/feed/application/usecase/FeedUsecase.java

@@ -210,10 +210,17 @@ private List<LinkedUser> getLinkedUsers(User author, List<Long> userIds, Feed fe
                 .toList();
     }
 
+    /**
+     * 피드에 공감을 추가
+     * 비관적 락(PESSIMISTIC_WRITE)을 사용하여 동시성 문제를 해결
+     * @see leets.leenk.domain.feed.domain.repository.FeedRepository#findByIdWithPessimisticLock
+     * @see leets.leenk.domain.user.domain.repository.UserRepository#findByIdWithPessimisticLock
+     */
     @Transactional
     public void reactToFeed(long userId, long feedId, ReactionRequest request) {
+        Feed feed = feedGetService.findByIdWithLock(feedId); // !락 순서 중요!
         User user = userGetService.findById(userId);
-        Feed feed = feedGetService.findById(feedId);
+
         validateReaction(feed, user);
 
         Reaction reaction = reactionGetService.findByFeedAndUser(feed, user)
@@ -225,6 +232,7 @@ public void reactToFeed(long userId, long feedId, ReactionRequest request) {
 
         long previousReactionCount = reaction.getReactionCount();
 
+        // Feed를 가져올 때 Fetch Join으로 작성자를 함께 가져와 락이 함께 걸리므로 별도의 락 필요 없음.
         feedUpdateService.updateTotalReaction(feed, reaction, feed.getUser(), request.reactionCount());
         feedNotificationUsecase.saveFirstReactionNotification(reaction);
 

src/main/java/leets/leenk/domain/feed/domain/repository/FeedRepository.java

@@ -1,11 +1,15 @@
 package leets.leenk.domain.feed.domain.repository;
 
+import jakarta.persistence.LockModeType;
+import jakarta.persistence.QueryHint;
 import leets.leenk.domain.feed.domain.entity.Feed;
 import leets.leenk.domain.user.domain.entity.User;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
 import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.QueryHints;
 import org.springframework.data.repository.query.Param;
 
 import java.time.LocalDateTime;
@@ -23,6 +27,16 @@ public interface FeedRepository extends JpaRepository<Feed, Long> {
     @Query("SELECT f FROM Feed f JOIN FETCH f.user WHERE f.deletedAt IS NULL AND f.id = :id")
     Optional<Feed> findByDeletedAtIsNullAndId(Long id);
 
+    /**
+     * 비관적 락을 사용하여 피드 조회 (동시성 제어용)
+     * 공감하기 등 동시 수정이 발생할 수 있는 경우 사용
+     * feed.user를 함께 가져오기 때문에 해당 유저에도 락이 함께 걸리니 주의
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @QueryHints(@QueryHint(name = "jakarta.persistence.lock.timeout", value = "2000"))
+    @Query("SELECT f FROM Feed f JOIN FETCH f.user WHERE f.deletedAt IS NULL AND f.id = :id")
+    Optional<Feed> findByIdWithPessimisticLock(@Param("id") Long id);
+
     /**
      * 현재 피드보다 최신인 피드 조회 (이전 피드)
      * createDate > currentCreateDate 조건으로 더 최근 피드를 ASC 정렬로 조회

src/main/java/leets/leenk/domain/feed/domain/service/FeedGetService.java

@@ -1,11 +1,13 @@
 package leets.leenk.domain.feed.domain.service;
 
+import jakarta.persistence.PessimisticLockException;
 import leets.leenk.domain.feed.application.exception.FeedNotFoundException;
 import leets.leenk.domain.feed.domain.entity.Feed;
 import leets.leenk.domain.feed.domain.repository.FeedRepository;
 import leets.leenk.domain.feed.domain.service.dto.FeedNavigationResult;
 import leets.leenk.domain.user.domain.entity.User;
 import leets.leenk.domain.user.domain.entity.UserBlock;
+import leets.leenk.global.common.exception.ResourceLockedException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
@@ -26,6 +28,19 @@ public Feed findById(long feedId) {
                 .orElseThrow(FeedNotFoundException::new);
     }
 
+    /**
+     * 비관적 락을 사용하여 피드 조회
+     * 동시 수정이 발생할 수 있는 경우 (공감하기 등) 사용
+     */
+    public Feed findByIdWithLock(long feedId) {
+        try {
+            return feedRepository.findByIdWithPessimisticLock(feedId)
+                    .orElseThrow(FeedNotFoundException::new);
+        } catch (PessimisticLockException e) {
+            throw new ResourceLockedException();
+        }
+    }
+
     public Slice<Feed> findAll(Pageable pageable, List<UserBlock> blockedUser) {
         List<Long> blockedUserIds = blockedUser.stream()
                 .map(UserBlock::getBlocked)

src/main/java/leets/leenk/domain/user/domain/repository/UserRepository.java

@@ -1,10 +1,14 @@
 package leets.leenk.domain.user.domain.repository;
 
+import jakarta.persistence.LockModeType;
+import jakarta.persistence.QueryHint;
 import leets.leenk.domain.user.domain.entity.User;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
 import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.QueryHints;
 import org.springframework.data.repository.query.Param;
 
 import java.time.LocalDate;
@@ -14,6 +18,15 @@
 
 public interface UserRepository extends JpaRepository<User, Long> {
 
+    /**
+     * 비관적 락을 사용하여 유저 조회
+     * 동시 수정이 발생할 수 있는 경우 (공감하기 등) 사용
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @QueryHints(@QueryHint(name = "jakarta.persistence.lock.timeout", value = "2000"))
+    @Query("SELECT u FROM User u WHERE u.id = :userId AND u.leaveDate IS NULL AND u.deleteDate IS NULL")
+    Optional<User> findByIdWithPessimisticLock(@Param("userId") long userId);
+
     Optional<User> findByIdAndLeaveDateIsNullAndDeleteDateIsNull(long userId);
 
     List<User> findAllByIdInAndLeaveDateIsNullAndDeleteDateIsNull(List<Long> userIds);

src/main/java/leets/leenk/domain/user/domain/service/user/UserGetService.java

@@ -23,6 +23,15 @@ public User findById(long userId) {
                 .orElseThrow(UserNotFoundException::new);
     }
 
+    /**
+     * 비관적 락을 사용하여 유저 조회
+     * 동시 수정이 발생할 수 있는 경우 (공감하기 등) 사용
+     */
+    public User findByIdWithLock(long userId) {
+        return userRepository.findByIdWithPessimisticLock(userId)
+                .orElseThrow(UserNotFoundException::new);
+    }
+
     public Optional<User> existById(long userId) {
         return userRepository.findById(userId);
     }

src/main/java/leets/leenk/global/common/exception/ErrorCode.java

@@ -10,6 +10,7 @@ public enum ErrorCode implements ErrorCodeInterface {
     // 3000번대: 서버 에러
     INTERNAL_SERVER_ERROR(3001, HttpStatus.INTERNAL_SERVER_ERROR, "서버 내부 오류입니다."),
     JSON_PROCESSING(3002, HttpStatus.INTERNAL_SERVER_ERROR, "JSON 처리 중 문제가 발생했습니다."),
+    RESOURCE_LOCKED(3003, HttpStatus.CONFLICT, "다른 사용자가 처리 중입니다. 잠시 후 다시 시도해주세요."),
 
     // 4000번대: 클라이언트 요청 에러
     INVALID_ARGUMENT(4001, HttpStatus.BAD_REQUEST, "잘못된 인자입니다."),

src/main/java/leets/leenk/global/common/exception/ResourceLockedException.java

@@ -0,0 +1,7 @@
+package leets.leenk.global.common.exception;
+
+public class ResourceLockedException extends BaseException{
+    public ResourceLockedException() {
+        super(ErrorCode.RESOURCE_LOCKED);
+    }
+}

src/test/java/leets/leenk/domain/feed/application/FeedUsecaseTest.java

@@ -356,8 +356,8 @@ void reactToFeed1() {
         User me = UserTestFixture.createUser(userId, "me");
         Feed myFeed = FeedTestFixture.createFeed(feedId, me);
 
+        given(feedGetService.findByIdWithLock(feedId)).willReturn(myFeed);
         given(userGetService.findById(userId)).willReturn(me);
-        given(feedGetService.findById(feedId)).willReturn(myFeed);
 
         ReactionRequest request = new ReactionRequest(1L);
 
@@ -380,8 +380,8 @@ void reactToFeed2() {
         User author = UserTestFixture.createUser(2L, "author");
         Feed feed = FeedTestFixture.createFeed(feedId, author);
 
+        given(feedGetService.findByIdWithLock(feedId)).willReturn(feed);
         given(userGetService.findById(userId)).willReturn(me);
-        given(feedGetService.findById(feedId)).willReturn(feed);
 
         Reaction reaction = ReactionTestFixture.createReaction(feed, me, 4);
         given(reactionGetService.findByFeedAndUser(feed, me)).willReturn(Optional.of(reaction));
@@ -408,8 +408,8 @@ void reactToFeed3() {
         User author = UserTestFixture.createUser(2L, "author");
         Feed feed = FeedTestFixture.createFeed(feedId, author);
 
+        given(feedGetService.findByIdWithLock(feedId)).willReturn(feed);
         given(userGetService.findById(userId)).willReturn(me);
-        given(feedGetService.findById(feedId)).willReturn(feed);
 
         given(reactionGetService.findByFeedAndUser(feed, me)).willReturn(Optional.empty());
 

src/test/kotlin/leets/leenk/config/MongoTestConfig.kt

@@ -0,0 +1,17 @@
+package leets.leenk.config
+
+import org.springframework.boot.test.context.TestConfiguration
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection
+import org.springframework.context.annotation.Bean
+import org.testcontainers.containers.MongoDBContainer
+
+private const val MONGO_IMAGE: String = "mongo:7.0"
+
+@TestConfiguration
+class MongoTestConfig {
+    @Bean
+    @ServiceConnection
+    fun mongoContainer(): MongoDBContainer {
+        return MongoDBContainer(MONGO_IMAGE)
+    }
+}

src/test/kotlin/leets/leenk/config/MysqlTestConfig.kt

@@ -0,0 +1,18 @@
+package leets.leenk.config
+
+import org.springframework.boot.test.context.TestConfiguration
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection
+import org.springframework.context.annotation.Bean
+import org.testcontainers.containers.MySQLContainer
+
+private const val MYSQL_IMAGE: String = "mysql:8.0.41"
+
+@TestConfiguration
+class MysqlTestConfig {
+    @Bean
+    @ServiceConnection
+    fun mysqlContainer(): MySQLContainer<*> {
+        return MySQLContainer(MYSQL_IMAGE)
+            .withDatabaseName("testdb")
+    }
+}

src/test/kotlin/leets/leenk/config/TestContainersTest.kt

@@ -0,0 +1,35 @@
+package leets.leenk.config
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.context.annotation.Import
+import org.testcontainers.containers.MongoDBContainer
+import org.testcontainers.containers.MySQLContainer
+
+@SpringBootTest
+@Import(MysqlTestConfig::class, MongoTestConfig::class)
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+class TestContainersTest(
+    private val mysqlContainer: MySQLContainer<*>,
+    private val mongoContainer: MongoDBContainer
+) : StringSpec({
+
+    "MySQL 컨테이너가 정상적으로 실행되어야 한다" {
+        mysqlContainer shouldNotBe null
+        mysqlContainer.isRunning shouldBe true
+        mysqlContainer.databaseName shouldBe "testdb"
+
+        println("MySQL Container JDBC URL: ${mysqlContainer.jdbcUrl}")
+    }
+
+    "MongoDB 컨테이너가 정상적으로 실행되어야 한다" {
+        mongoContainer shouldNotBe null
+        mongoContainer.isRunning shouldBe true
+
+        println("MongoDB Container Connection String: ${mongoContainer.connectionString}")
+        println("MongoDB Container Replica Set URL: ${mongoContainer.replicaSetUrl}")
+    }
+})

src/test/kotlin/leets/leenk/domain/feed/application/domain/service/FeedGetService.kt

@@ -0,0 +1,27 @@
+package leets.leenk.domain.feed.application.domain.service
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.DescribeSpec
+import io.mockk.every
+import io.mockk.mockk
+import jakarta.persistence.PessimisticLockException
+import leets.leenk.domain.feed.domain.repository.FeedRepository
+import leets.leenk.domain.feed.domain.service.FeedGetService
+import leets.leenk.global.common.exception.ResourceLockedException
+
+class FeedGetServiceTest : DescribeSpec({
+    val feedRepository = mockk<FeedRepository>()
+    val feedGetService = FeedGetService(feedRepository)
+
+    describe("피드 리액션 기능") {
+        context("동시 요청 시 락 타임아웃 발생 시") {
+            it("DB에서 락 예외가 발생하면 커스텀 예외로 변환해야 한다") {
+                every { feedRepository.findByIdWithPessimisticLock(any()) } throws PessimisticLockException()
+
+                shouldThrow<ResourceLockedException> {
+                    feedGetService.findByIdWithLock(1L)
+                }
+            }
+        }
+    }
+})