[feat] 미니게임 결과 저장 Bulk Insert 전환으로 DB 커넥션 점유 시간 최소화 (#1096)

* feat: MiniGame 결과 대량 삽입을 위한 Repository 추가

- MiniGameResultBulkRepository 및 구현체(MiniGameResultBulkRepositoryImpl) 추가
- JdbcTemplate을 사용한 bulkInsert 메서드 구현
- BatchPreparedStatementSetter를 활용한 배치 삽입 로직 처리
- MiniGame 결과 대량 처리 성능 최적화

* feat: MiniGame 결과 벌크 저장 로직 추가 및 성능 최적화

- MiniGameResult 벌크 삽입을 위한 List 생성 및 처리 로직 추가
- MiniGameResultJpaRepository에 bulkInsert 메서드 연결
- 로깅 정보에 저장된 플레이어 수 추가
- 결과 저장 성능 개선 및 부하 감소 위해 배열 기반 처리 적용

* feat: MySQL 데이터베이스 Hikari 설정 추가

- hikari.data-source-properties.rewriteBatchedStatements 설정 추가
- 대량 삽입 시 성능 최적화 위한 옵션 활성화

* fix: MiniGame 결과 벌크 삽입 시 빈 리스트 처리 로직 추가

- 결과 데이터가 없는 경우 불필요한 DB 호출 방지를 위해 early return 로직 추가
- MiniGameResultBulkRepositoryImpl의 bulkInsert 메서드에 유효성 검증 로직 보완

* refactor: MiniGame 결과 저장 로직 성능 최적화 및 리팩토링

- Room 플레이어 데이터를 한 번에 조회하도록 findByRoomSessionAndPlayerNameIn 메서드 추가
- PlayerEntity 검색 시 Map 데이터 구조 활용으로 중복 호출 제거
- MiniGameResultSaveEventListener 코드 가독성 및 효율성 개선

* refactor: MiniGameResultSaveEventListener 중복 키 처리 로직 개선

- Collectors.toMap 사용 시 중복 키 발생 처리 로직 추가
- 기존 값 유지로 중복 키로 인한 오류 방지
- 코드를 안전하고 명시적으로 개선하여 가독성 향상

Author: theminjunchoi

backend/src/main/java/coffeeshout/minigame/event/MiniGameResultSaveEventListener.java

@@ -19,7 +19,11 @@
 import coffeeshout.room.infra.persistence.RoomEntity;
 import coffeeshout.room.infra.persistence.RoomJpaRepository;
 import jakarta.transaction.Transactional;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.event.EventListener;
@@ -60,24 +64,40 @@ public void handle(MiniGameFinishedEvent event) {
         final MiniGameResult result = miniGame.getResult();
         final Map<Player, MiniGameScore> scores = miniGame.getScores();
 
+        final List<String> playerNames = room.getPlayers().stream()
+                .map(player -> player.getName().value())
+                .toList();
+
+        final Map<String, PlayerEntity> playerEntityMap = playerJpaRepository
+                .findByRoomSessionAndPlayerNameIn(roomEntity, playerNames)
+                .stream()
+                .collect(Collectors.toMap(
+                        PlayerEntity::getPlayerName,
+                        Function.identity(),
+                        (existing, replacement) -> existing
+                ));
+
+        final List<MiniGameResultEntity> resultEntities = new ArrayList<>();
+
         for (Player player : room.getPlayers()) {
-            final PlayerEntity playerEntity = playerJpaRepository.findByRoomSessionAndPlayerName(roomEntity,
-                            player.getName().value())
-                    .orElseThrow(() -> new IllegalArgumentException("플레이어가 존재하지 않습니다: " + player.getName().value()));
+            final PlayerEntity playerEntity = playerEntityMap.get(player.getName().value());
+            if (playerEntity == null) {
+                throw new IllegalArgumentException("플레이어가 존재하지 않습니다: " + player.getName().value());
+            }
 
             final Integer rank = result.getPlayerRank(player);
             final Long score = scores.get(player).getValue();
 
-            final MiniGameResultEntity resultEntity = new MiniGameResultEntity(
+            resultEntities.add(new MiniGameResultEntity(
                     miniGameEntity,
                     playerEntity,
                     rank,
                     score
-            );
-
-            miniGameResultJpaRepository.save(resultEntity);
+            ));
         }
 
-        log.info("미니게임 결과 저장 완료: joinCode={}", event.joinCode());
+        miniGameResultJpaRepository.bulkInsert(resultEntities);
+
+        log.info("미니게임 결과 벌크 저장 완료: joinCode={}, playerCount={}", event.joinCode(), resultEntities.size());
     }
 }

backend/src/main/java/coffeeshout/minigame/infra/persistence/MiniGameResultBulkRepository.java

@@ -0,0 +1,8 @@
+package coffeeshout.minigame.infra.persistence;
+
+import java.util.List;
+
+public interface MiniGameResultBulkRepository {
+
+    void bulkInsert(List<MiniGameResultEntity> resultEntities);
+}

backend/src/main/java/coffeeshout/minigame/infra/persistence/MiniGameResultBulkRepositoryImpl.java

@@ -0,0 +1,45 @@
+package coffeeshout.minigame.infra.persistence;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.jdbc.core.BatchPreparedStatementSetter;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+@RequiredArgsConstructor
+public class MiniGameResultBulkRepositoryImpl implements MiniGameResultBulkRepository {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    @Override
+    public void bulkInsert(List<MiniGameResultEntity> resultEntities) {
+        if (resultEntities.isEmpty()) {
+            return;
+        }
+
+        final String sql = """
+                INSERT INTO mini_game_result (mini_game_play_id, player_id, player_rank, score, mini_game_type, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """;
+
+        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
+            @Override
+            public void setValues(PreparedStatement ps, int i) throws SQLException {
+                final MiniGameResultEntity entity = resultEntities.get(i);
+                ps.setLong(1, entity.getMiniGamePlay().getId());
+                ps.setLong(2, entity.getPlayer().getId());
+                ps.setInt(3, entity.getRank());
+                ps.setLong(4, entity.getScore());
+                ps.setString(5, entity.getMiniGameType().name());
+                ps.setTimestamp(6, Timestamp.valueOf(entity.getCreatedAt()));
+            }
+
+            @Override
+            public int getBatchSize() {
+                return resultEntities.size();
+            }
+        });
+    }
+}

backend/src/main/java/coffeeshout/minigame/infra/persistence/MiniGameResultJpaRepository.java

@@ -2,7 +2,8 @@
 
 import org.springframework.data.repository.Repository;
 
-public interface MiniGameResultJpaRepository extends Repository<MiniGameResultEntity, Long> {
+public interface MiniGameResultJpaRepository extends Repository<MiniGameResultEntity, Long>,
+        MiniGameResultBulkRepository {
 
     MiniGameResultEntity save(MiniGameResultEntity miniGameResultEntity);
 }

backend/src/main/java/coffeeshout/room/infra/persistence/PlayerJpaRepository.java

@@ -1,10 +1,13 @@
 package coffeeshout.room.infra.persistence;
 
+import java.util.List;
 import java.util.Optional;
 import org.springframework.data.repository.Repository;
 
 public interface PlayerJpaRepository extends Repository<PlayerEntity, Long> {
     PlayerEntity save(PlayerEntity playerEntity);
 
     Optional<PlayerEntity> findByRoomSessionAndPlayerName(RoomEntity roomSession, String playerName);
+
+    List<PlayerEntity> findByRoomSessionAndPlayerNameIn(RoomEntity roomSession, List<String> playerNames);
 }

backend/src/main/resources/application.yml

@@ -7,6 +7,9 @@ spring:
     username: ${MYSQL_USERNAME}
     password: ${MYSQL_PASSWORD}
     driver-class-name: com.mysql.cj.jdbc.Driver
+    hikari:
+      data-source-properties:
+        rewriteBatchedStatements: true
   lifecycle:
     timeout-per-shutdown-phase: 5m
   data: