setting: add querydsl dependency (#31)

* setting: QueryDSL 5.1.0 (Jakarta) 의존성 추가 (#30)

* setting: JPAQueryFactory 빈 설정 추가 (#30)

* feat: QueryDSL Repository 생성 및 JpaRepository 쿼리를 메서드 체인으로 전환 (#30)

* refactor: JpaRepository에서 커스텀 쿼리 제거, CRUD 전용으로 축소 (#30)

* refactor: Adapter에서 QueryDSL Repository 주입으로 변경 (#30)

Author: toychip

gradle/libs.versions.toml

@@ -3,6 +3,7 @@ springBoot = "3.3.0"
 springDependencyManagement = "1.1.5"
 kotlinPlugin = "2.0.0"
 jjwt = "0.12.6"
+querydsl = "5.1.0"
 ktLintPlugin = "12.1.1"
 gradleBuildScanPlugin = "3.18.1"
 javaVersion = "21"
@@ -37,6 +38,10 @@ spring-boot-starter-jpa = { group = "org.springframework.boot", name = "spring-b
 spring-boot-starter-redis = { group = "org.springframework.boot", name = "spring-boot-starter-data-redis" }
 spring-boot-docs = { group = "org.springdoc", name = "springdoc-openapi-starter-webmvc-ui", version = "2.5.0" }
 
+# QueryDSL
+querydsl-jpa = { group = "com.querydsl", name = "querydsl-jpa", version.ref = "querydsl" }
+querydsl-apt = { group = "com.querydsl", name = "querydsl-apt", version.ref = "querydsl" }
+
 # MySQL
 mysql = { group = "com.mysql", name = "mysql-connector-j" }
 

linktrip-output-persistence/mysql/build.gradle.kts

@@ -5,6 +5,10 @@ plugins {
 dependencies {
     implementation(project(":linktrip-application"))
     implementation(libs.bundles.adaptor.persistence.mysql)
+
+    // QueryDSL (Jakarta)
+    implementation(variantOf(libs.querydsl.jpa) { classifier("jakarta") })
+    kapt(variantOf(libs.querydsl.apt) { classifier("jakarta") })
 }
 
 allOpen {

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/adapter/PlaceEnrichPersistenceAdapter.kt

@@ -5,7 +5,7 @@ import com.linktrip.application.domain.video.PlaceEnrichResult
 import com.linktrip.application.port.output.persistence.PlaceEnrichPersistencePort
 import com.linktrip.output.persistence.mysql.entity.PlaceEntity
 import com.linktrip.output.persistence.mysql.repository.PlaceJpaRepository
-import com.linktrip.output.persistence.mysql.repository.VideoScheduleItemJpaRepository
+import com.linktrip.output.persistence.mysql.repository.VideoScheduleItemQuerydslRepository
 import mu.KotlinLogging
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.Transactional
@@ -14,7 +14,7 @@ private val logger = KotlinLogging.logger {}
 
 @Component
 class PlaceEnrichPersistenceAdapter(
-    private val videoScheduleItemJpaRepository: VideoScheduleItemJpaRepository,
+    private val scheduleItemQuerydslRepository: VideoScheduleItemQuerydslRepository,
     private val placeJpaRepository: PlaceJpaRepository,
 ) : PlaceEnrichPersistencePort {
     @Transactional
@@ -25,7 +25,7 @@ class PlaceEnrichPersistenceAdapter(
         if (results.isEmpty()) return
 
         val itemMap =
-            videoScheduleItemJpaRepository
+            scheduleItemQuerydslRepository
                 .findByVideoSummaryIdOrderByDayAscItemOrderAsc(videoSummaryId)
                 .associateBy { it.id }
 

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/adapter/VideoScheduleItemAdapter.kt

@@ -2,39 +2,38 @@ package com.linktrip.output.persistence.mysql.adapter
 
 import com.linktrip.application.domain.video.VideoScheduleItem
 import com.linktrip.application.port.output.persistence.VideoScheduleItemPersistencePort
-import com.linktrip.output.persistence.mysql.entity.PlaceEntity
 import com.linktrip.output.persistence.mysql.entity.VideoScheduleItemEntity
 import com.linktrip.output.persistence.mysql.repository.VideoScheduleItemJpaRepository
+import com.linktrip.output.persistence.mysql.repository.VideoScheduleItemQuerydslRepository
 import org.springframework.stereotype.Component
 
 @Component
 class VideoScheduleItemAdapter(
-    private val videoScheduleItemJpaRepository: VideoScheduleItemJpaRepository,
+    private val jpaRepository: VideoScheduleItemJpaRepository,
+    private val querydslRepository: VideoScheduleItemQuerydslRepository,
 ) : VideoScheduleItemPersistencePort {
     override fun saveAll(items: List<VideoScheduleItem>) {
         val entities = items.map { VideoScheduleItemEntity.from(it) }
-        videoScheduleItemJpaRepository.saveAll(entities)
+        jpaRepository.saveAll(entities)
     }
 
     override fun findByVideoSummaryId(videoSummaryId: String): List<VideoScheduleItem> =
-        videoScheduleItemJpaRepository
+        querydslRepository
             .findByVideoSummaryIdOrderByDayAscItemOrderAsc(videoSummaryId)
             .map { it.toDomain() }
 
     override fun findByVideoSummaryIdWithPlace(videoSummaryId: String): List<VideoScheduleItem> =
-        videoScheduleItemJpaRepository
+        querydslRepository
             .findByVideoSummaryIdWithPlace(videoSummaryId)
             .map { row ->
-                val item = (row[0] as VideoScheduleItemEntity).toDomain()
-                val place = (row[1] as? PlaceEntity)?.toDomain()
-                item.copy(place = place)
+                row.item.toDomain().copy(place = row.place?.toDomain())
             }
 
     override fun findRetryableItems(videoSummaryId: String): List<VideoScheduleItem> =
-        videoScheduleItemJpaRepository
+        querydslRepository
             .findRetryableItems(videoSummaryId)
             .map { it.toDomain() }
 
     override fun findVideoSummaryIdsWithRetryableItems(): List<String> =
-        videoScheduleItemJpaRepository.findVideoSummaryIdsWithRetryableItems()
+        querydslRepository.findVideoSummaryIdsWithRetryableItems()
 }

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/adapter/YouTubeChannelPersistenceAdapter.kt

@@ -6,14 +6,18 @@ import com.linktrip.application.port.output.persistence.YouTubeChannelPersistenc
 import com.linktrip.output.persistence.mysql.entity.YouTubeChannelEntity
 import com.linktrip.output.persistence.mysql.entity.YouTubeRecentVideoEntity
 import com.linktrip.output.persistence.mysql.repository.YouTubeChannelJpaRepository
+import com.linktrip.output.persistence.mysql.repository.YouTubeChannelQuerydslRepository
 import com.linktrip.output.persistence.mysql.repository.YouTubeRecentVideoJpaRepository
+import com.linktrip.output.persistence.mysql.repository.YouTubeRecentVideoQuerydslRepository
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.Transactional
 
 @Component("youtubeChannelDbAdapter")
 class YouTubeChannelPersistenceAdapter(
-    private val youTubeChannelJpaRepository: YouTubeChannelJpaRepository,
-    private val youTubeRecentVideoJpaRepository: YouTubeRecentVideoJpaRepository,
+    private val channelJpaRepository: YouTubeChannelJpaRepository,
+    private val channelQuerydslRepository: YouTubeChannelQuerydslRepository,
+    private val recentVideoJpaRepository: YouTubeRecentVideoJpaRepository,
+    private val recentVideoQuerydslRepository: YouTubeRecentVideoQuerydslRepository,
 ) : YouTubeChannelPersistencePort {
     @Transactional
     override fun saveAll(channels: List<YouTubeChannelDetail>) {
@@ -23,18 +27,18 @@ class YouTubeChannelPersistenceAdapter(
 
         // 채널 upsert
         val existingMap =
-            youTubeChannelJpaRepository.findAllByChannelIdIn(channelIds)
+            channelQuerydslRepository.findAllByChannelIdIn(channelIds)
                 .associateBy { it.channelId }
 
         val entitiesToSave =
             channels.map { detail ->
                 existingMap[detail.channelId]?.apply { updateFrom(detail) }
                     ?: YouTubeChannelEntity.from(IdGenerator.generate(), detail)
             }
-        youTubeChannelJpaRepository.saveAll(entitiesToSave)
+        channelJpaRepository.saveAll(entitiesToSave)
 
         // 최신 영상: 기존 삭제 후 새로 저장
-        youTubeRecentVideoJpaRepository.deleteAllByChannelIdIn(channelIds)
+        recentVideoQuerydslRepository.deleteAllByChannelIdIn(channelIds)
 
         val videoEntities =
             channels.flatMap { channel ->
@@ -43,19 +47,19 @@ class YouTubeChannelPersistenceAdapter(
                 }
             }
         if (videoEntities.isNotEmpty()) {
-            youTubeRecentVideoJpaRepository.saveAll(videoEntities)
+            recentVideoJpaRepository.saveAll(videoEntities)
         }
     }
 
     @Transactional(readOnly = true)
     override fun findAll(): List<YouTubeChannelDetail> {
-        val channels = youTubeChannelJpaRepository.findAllByOrderBySubscriberCountDesc()
+        val channels = channelQuerydslRepository.findAllOrderBySubscriberCountDesc()
         if (channels.isEmpty()) return emptyList()
 
         // N+1 방지: 채널 ID 목록으로 한번에 조회 후 그룹핑
         val channelIds = channels.map { it.channelId }
         val recentVideosMap =
-            youTubeRecentVideoJpaRepository.findAllByChannelIdIn(channelIds)
+            recentVideoQuerydslRepository.findAllByChannelIdIn(channelIds)
                 .map { it.toDomain() }
                 .groupBy { it.channelId }
                 .mapValues { (_, videos) ->

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/adapter/YouTubeVideoPersistenceAdapter.kt

@@ -4,7 +4,7 @@ import com.linktrip.application.domain.common.CursorPage
 import com.linktrip.application.domain.youtube.YouTubeVideoDetail
 import com.linktrip.application.port.output.persistence.YouTubeVideoPersistencePort
 import com.linktrip.output.persistence.mysql.entity.YouTubeVideoEntity
-import com.linktrip.output.persistence.mysql.repository.YouTubeVideoJpaRepository
+import com.linktrip.output.persistence.mysql.repository.YouTubeVideoQuerydslRepository
 import jakarta.persistence.EntityManager
 import org.springframework.data.domain.PageRequest
 import org.springframework.stereotype.Component
@@ -13,7 +13,7 @@ import java.time.LocalDateTime
 
 @Component("youtubeVideoDbAdapter")
 class YouTubeVideoPersistenceAdapter(
-    private val youTubeVideoJpaRepository: YouTubeVideoJpaRepository,
+    private val querydslRepository: YouTubeVideoQuerydslRepository,
     private val entityManager: EntityManager,
 ) : YouTubeVideoPersistencePort {
     @Transactional
@@ -26,21 +26,21 @@ class YouTubeVideoPersistenceAdapter(
 
     @Transactional(readOnly = true)
     override fun findExistingVideoIds(videoIds: List<String>): Set<String> =
-        youTubeVideoJpaRepository.findVideoIdsByVideoIdIn(videoIds).toSet()
+        querydslRepository.findVideoIdsByVideoIdIn(videoIds).toSet()
 
     @Transactional(readOnly = true)
     override fun findAll(): List<YouTubeVideoDetail> =
-        youTubeVideoJpaRepository.findAllByOrderByViewCountDesc()
+        querydslRepository.findAllOrderByViewCountDesc()
             .map { it.toDomain() }
 
     @Transactional(readOnly = true)
     override fun findAllByCountry(country: String): List<YouTubeVideoDetail> =
-        youTubeVideoJpaRepository.findAllByCountryOrderByViewCountDesc(country)
+        querydslRepository.findAllByCountryOrderByViewCountDesc(country)
             .map { it.toDomain() }
 
     @Transactional(readOnly = true)
     override fun findAllByRegion(region: String): List<YouTubeVideoDetail> =
-        youTubeVideoJpaRepository.findAllByRegionOrderByViewCountDesc(region)
+        querydslRepository.findAllByRegionOrderByViewCountDesc(region)
             .map { it.toDomain() }
 
     @Transactional(readOnly = true)
@@ -53,9 +53,9 @@ class YouTubeVideoPersistenceAdapter(
 
         val entities =
             if (cursor != null) {
-                youTubeVideoJpaRepository.findAllByThemeAndCreatedAtBefore(theme, cursor, pageable)
+                querydslRepository.findAllByThemeAndCreatedAtBefore(theme, cursor, pageable)
             } else {
-                youTubeVideoJpaRepository.findAllByTheme(theme, pageable)
+                querydslRepository.findAllByTheme(theme, pageable)
             }
 
         val hasNext = entities.size > size

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/config/QuerydslConfig.kt

@@ -0,0 +1,14 @@
+package com.linktrip.output.persistence.mysql.config
+
+import com.querydsl.jpa.impl.JPAQueryFactory
+import jakarta.persistence.EntityManager
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+class QuerydslConfig(
+    private val entityManager: EntityManager,
+) {
+    @Bean
+    fun jpaQueryFactory(): JPAQueryFactory = JPAQueryFactory(entityManager)
+}

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/repository/VideoScheduleItemJpaRepository.kt

@@ -1,49 +1,6 @@
 package com.linktrip.output.persistence.mysql.repository
 
-import com.linktrip.application.domain.video.Category
 import com.linktrip.output.persistence.mysql.entity.VideoScheduleItemEntity
 import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.data.jpa.repository.Query
 
-interface VideoScheduleItemJpaRepository : JpaRepository<VideoScheduleItemEntity, String> {
-    fun findByVideoSummaryIdOrderByDayAscItemOrderAsc(videoSummaryId: String): List<VideoScheduleItemEntity>
-
-    @Query(
-        """
-        SELECT i, p FROM VideoScheduleItemEntity i
-        LEFT JOIN PlaceEntity p ON i.placeId = p.id
-        WHERE i.videoSummaryId = :videoSummaryId
-        ORDER BY i.day ASC, i.itemOrder ASC
-        """,
-    )
-    fun findByVideoSummaryIdWithPlace(videoSummaryId: String): List<Array<Any>>
-
-    @Query(
-        """
-        SELECT e FROM VideoScheduleItemEntity e
-        WHERE e.videoSummaryId = :videoSummaryId
-          AND e.placeId IS NULL
-          AND e.category <> :excludeCategory
-          AND e.placeSearchCount < :maxSearchCount
-        ORDER BY e.day ASC, e.itemOrder ASC
-        """,
-    )
-    fun findRetryableItems(
-        videoSummaryId: String,
-        excludeCategory: Category = Category.TRANSPORTATION,
-        maxSearchCount: Int = 10,
-    ): List<VideoScheduleItemEntity>
-
-    @Query(
-        """
-        SELECT DISTINCT e.videoSummaryId FROM VideoScheduleItemEntity e
-        WHERE e.placeId IS NULL
-          AND e.category <> :excludeCategory
-          AND e.placeSearchCount < :maxSearchCount
-        """,
-    )
-    fun findVideoSummaryIdsWithRetryableItems(
-        excludeCategory: Category = Category.TRANSPORTATION,
-        maxSearchCount: Int = 10,
-    ): List<String>
-}
+interface VideoScheduleItemJpaRepository : JpaRepository<VideoScheduleItemEntity, String>

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/repository/VideoScheduleItemQuerydslRepository.kt

@@ -0,0 +1,78 @@
+package com.linktrip.output.persistence.mysql.repository
+
+import com.linktrip.application.domain.video.Category
+import com.linktrip.output.persistence.mysql.entity.QPlaceEntity
+import com.linktrip.output.persistence.mysql.entity.QVideoScheduleItemEntity
+import com.linktrip.output.persistence.mysql.entity.VideoScheduleItemEntity
+import com.linktrip.output.persistence.mysql.repository.dto.ScheduleItemWithPlace
+import com.querydsl.jpa.impl.JPAQueryFactory
+import org.springframework.stereotype.Repository
+
+@Repository
+class VideoScheduleItemQuerydslRepository(
+    private val queryFactory: JPAQueryFactory,
+) {
+    private val scheduleItem = QVideoScheduleItemEntity.videoScheduleItemEntity
+    private val place = QPlaceEntity.placeEntity
+
+    fun findByVideoSummaryIdOrderByDayAscItemOrderAsc(videoSummaryId: String): List<VideoScheduleItemEntity> =
+        queryFactory
+            .selectFrom(scheduleItem)
+            .where(scheduleItem.videoSummaryId.eq(videoSummaryId))
+            .orderBy(
+                scheduleItem.day.asc(),
+                scheduleItem.itemOrder.asc(),
+            )
+            .fetch()
+
+    fun findByVideoSummaryIdWithPlace(videoSummaryId: String): List<ScheduleItemWithPlace> =
+        queryFactory
+            .select(scheduleItem, place)
+            .from(scheduleItem)
+            .leftJoin(place).on(scheduleItem.placeId.eq(place.id))
+            .where(scheduleItem.videoSummaryId.eq(videoSummaryId))
+            .orderBy(
+                scheduleItem.day.asc(),
+                scheduleItem.itemOrder.asc(),
+            )
+            .fetch()
+            .map { tuple ->
+                ScheduleItemWithPlace(
+                    item = tuple.get(scheduleItem)!!,
+                    place = tuple.get(place),
+                )
+            }
+
+    fun findRetryableItems(
+        videoSummaryId: String,
+        excludeCategory: Category = Category.TRANSPORTATION,
+        maxSearchCount: Int = 10,
+    ): List<VideoScheduleItemEntity> =
+        queryFactory
+            .selectFrom(scheduleItem)
+            .where(
+                scheduleItem.videoSummaryId.eq(videoSummaryId),
+                scheduleItem.placeId.isNull,
+                scheduleItem.category.ne(excludeCategory),
+                scheduleItem.placeSearchCount.lt(maxSearchCount),
+            )
+            .orderBy(
+                scheduleItem.day.asc(),
+                scheduleItem.itemOrder.asc(),
+            )
+            .fetch()
+
+    fun findVideoSummaryIdsWithRetryableItems(
+        excludeCategory: Category = Category.TRANSPORTATION,
+        maxSearchCount: Int = 10,
+    ): List<String> =
+        queryFactory
+            .selectDistinct(scheduleItem.videoSummaryId)
+            .from(scheduleItem)
+            .where(
+                scheduleItem.placeId.isNull,
+                scheduleItem.category.ne(excludeCategory),
+                scheduleItem.placeSearchCount.lt(maxSearchCount),
+            )
+            .fetch()
+}

linktrip-output-persistence/mysql/src/main/kotlin/com/linktrip/output/persistence/mysql/repository/YouTubeChannelJpaRepository.kt

@@ -3,8 +3,4 @@ package com.linktrip.output.persistence.mysql.repository
 import com.linktrip.output.persistence.mysql.entity.YouTubeChannelEntity
 import org.springframework.data.jpa.repository.JpaRepository
 
-interface YouTubeChannelJpaRepository : JpaRepository<YouTubeChannelEntity, String> {
-    fun findAllByChannelIdIn(channelIds: List<String>): List<YouTubeChannelEntity>
-
-    fun findAllByOrderBySubscriberCountDesc(): List<YouTubeChannelEntity>
-}
+interface YouTubeChannelJpaRepository : JpaRepository<YouTubeChannelEntity, String>