🚀 2025년 코프링 필수 라이브러리 5종 완벽 가이드

🎯 한 줄 요약

QueryDSL 대신 뭘 써야 할까? 카카오, 네이버, 토스가 선택한 Kotlin + Spring Boot 필수 라이브러리를 실전 코드와 함께 소개합니다!

🤔 자바 라이브러리 그대로 쓰면 안 되나?

솔직히 말씀드리면, 코틀린의 진짜 매력을 50%도 못 느끼고 있는 겁니다!

• "QueryDSL 메타모델 생성이 너무 번거로워..."
• "Mockito가 코틀린 suspend 함수를 못 모킹해..."
• "JUnit으로 코루틴 테스트하기 너무 복잡해..."

이제 코틀린 네이티브 라이브러리로 갈아탈 시간입니다! 🔥

1️⃣ Kotlin JDSL - QueryDSL의 완벽한 대체제

🎯 왜 JDSL인가?

LINE에서 만든 Kotlin JDSL은 QueryDSL의 모든 장점을 가지면서도 더 간단합니다!

QueryDSL vs JDSL 비교:

특징	QueryDSL	Kotlin JDSL
메타모델	Q클래스 생성 필요	KProperty 직접 사용
설정	복잡한 Gradle 설정	Spring Boot Starter
유지보수	커뮤니티 의존	LINE 공식 지원
코틀린 친화성	Java 우선 설계	Kotlin Native 설계

💻 실제 사용법

의존성 추가

dependencies {
    implementation("com.linecorp.kotlin-jdsl:spring-data-kotlin-jdsl-starter:3.4.1")
}

Repository 구현

@Repository
interface UserRepository : JpaRepository<User, Long>, KotlinJdslJpqlExecutor {
    
    // QueryDSL 방식
    // fun findActiveUsers(): List<User> {
    //     return queryFactory
    //         .selectFrom(QUser.user)
    //         .where(QUser.user.status.eq("ACTIVE"))
    //         .fetch()
    // }
    
    // JDSL 방식 - 메타모델 불필요
    fun findActiveUsers() = findAll {
        select(entity(User::class))
        from(entity(User::class))
        where(col(User::status).eq("ACTIVE"))
    }
    
    // 복잡한 조인도 간단하게
    fun findUsersWithOrders() = findAll {
        selectNew<UserWithOrderDto>(
            col(User::id),
            col(User::name),
            count(Order::id)
        )
        from(entity(User::class))
        leftJoin(User::orders)
        groupBy(col(User::id))
        having(count(Order::id).gt(5))
    }
}

🏢 실제 도입 사례

• Spoqa: QueryDSL → JDSL 마이그레이션 (2024년 공식 발표)
• LINE 내부: 다수 서비스에서 활용
• 오픈소스 커뮤니티: 점진적 도입 확산

2️⃣ Komapper - 컴파일 타임 SQL 검증의 혁명

🎯 왜 Komapper인가?

런타임 SQL 에러는 이제 그만! Komapper는 컴파일 시점에 SQL을 검증합니다.

주요 특징:

• 컴파일 타임 SQL 타입 체크 ✅
• 배치 작업 최적화 (Hibernate보다 20% 빠름)
• R2DBC 네이티브 지원
• Spring Boot 3 완벽 통합

💻 실제 사용법

Entity 정의

@KomapperEntity
@Table("users")
data class User(
    @KomapperId
    @Column("user_id")
    val id: Long = 0,
    
    @Column("username")
    val username: String,
    
    @Column("created_at")
    val createdAt: LocalDateTime = LocalDateTime.now()
)

Repository 구현

@Repository
class UserRepository(private val db: Database) {
    
    // 컴파일 타임에 SQL 검증!
    fun findByUsername(username: String): User? {
        val query = QueryDsl.from(u)
            .where { u.username eq username }
            .singleOrNull()
        
        return db.runQuery(query)
    }
    
    // 배치 INSERT - 매우 빠름
    suspend fun batchInsert(users: List<User>) {
        val query = QueryDsl.insert(u).batch(users)
        db.runQuery(query)
    }
    
    // 동적 쿼리도 타입 세이프
    fun search(criteria: SearchCriteria): List<User> {
        val query = QueryDsl.from(u).where {
            criteria.username?.let { u.username contains it }
            criteria.minAge?.let { u.age gte it }
        }
        return db.runQuery(query)
    }
}

🎯 Komapper 주요 특징

• 컴파일 타임 검증: 런타임 에러 방지
• R2DBC 지원: 비동기 데이터베이스 연결
• 배치 최적화: 대용량 데이터 처리에 유리
• Spring Boot 3: 완벽한 통합 지원

3️⃣ Kotest - JUnit은 이제 안녕

🎯 왜 Kotest인가?

JUnit의 한계를 뛰어넘는 코틀린 네이티브 테스팅!

JUnit vs Kotest 비교:

기능	JUnit 5	Kotest
코루틴	별도 설정 필요	네이티브 지원
스펙 스타일	1가지 (@Test)	10가지 스타일
프로퍼티 테스팅	외부 라이브러리	내장 지원
DSL	어노테이션 기반	함수형 DSL

💻 실제 사용법

다양한 스펙 스타일

// 1. FunSpec (간단한 테스트)
class UserServiceTest : FunSpec({
    
    test("사용자 생성 성공") {
        val service = UserService()
        val user = service.create("김코틀린")
        
        user.name shouldBe "김코틀린"
        user.id shouldBeGreaterThan 0
    }
    
    test("중복 사용자명 예외") {
        val service = UserService()
        service.create("김코틀린")
        
        shouldThrow<DuplicateUsernameException> {
            service.create("김코틀린")
        }
    }
})

// 2. BehaviorSpec (BDD 스타일)
class OrderServiceTest : BehaviorSpec({
    
    Given("주문이 있을 때") {
        val order = Order(id = 1, status = "PENDING")
        
        When("결제를 완료하면") {
            order.complete()
            
            Then("상태가 COMPLETED로 변경된다") {
                order.status shouldBe "COMPLETED"
            }
        }
        
        When("주문을 취소하면") {
            order.cancel()
            
            Then("상태가 CANCELLED로 변경된다") {
                order.status shouldBe "CANCELLED"
            }
        }
    }
})

// 3. StringSpec (가장 간결)
class CalculatorTest : StringSpec({
    
    "1 + 1 = 2" {
        (1 + 1) shouldBe 2
    }
    
    "문자열 연결" {
        "Hello, " + "World!" shouldBe "Hello, World!"
    }
})

코루틴 테스트

class AsyncServiceTest : FunSpec({
    
    test("비동기 API 호출").config(timeout = 5.seconds) {
        val service = AsyncService()
        
        // suspend 함수 직접 테스트!
        val result = service.fetchDataAsync()
        
        result shouldNotBe null
        result.size shouldBeGreaterThan 0
    }
    
    test("동시 실행 테스트") {
        val service = AsyncService()
        
        // 100개 동시 실행
        val results = (1..100).map { id ->
            async { service.process(id) }
        }.awaitAll()
        
        results.distinct().size shouldBe 100
    }
})

프로퍼티 기반 테스팅

class PropertyTest : FunSpec({
    
    test("모든 양수에 대해 성립") {
        checkAll<Int> { num ->
            whenever(num > 0) {
                (num * 2) shouldBeGreaterThan num
            }
        }
    }
    
    test("문자열 역순 테스트") {
        checkAll<String> { str ->
            str.reversed().reversed() shouldBe str
        }
    }
})

4️⃣ MockK - Mockito는 잊어라

🎯 왜 MockK인가?

코틀린을 위해 처음부터 설계된 모킹 라이브러리!

Mockito vs MockK 비교:

기능	Mockito	MockK
Final 클래스	inline mock 필요	기본 지원
Suspend 함수	지원 불가	coEvery/coVerify
DSL	Java 스타일	Kotlin DSL
언어 친화성	Java 우선	Kotlin 전용

💻 실제 사용법

기본 모킹

@Test
fun `사용자 조회 테스트`() {
    // Given
    val repository = mockk<UserRepository>()
    val service = UserService(repository)
    
    every { repository.findById(1L) } returns User(1L, "김코틀린")
    
    // When
    val user = service.getUser(1L)
    
    // Then
    user.name shouldBe "김코틀린"
    verify(exactly = 1) { repository.findById(1L) }
}

Suspend 함수 모킹

@Test
fun `비동기 API 모킹`() = runTest {
    // Mockito는 이게 안 됨!
    val client = mockk<ApiClient>()
    
    coEvery { client.fetchData() } returns listOf("A", "B", "C")
    
    val service = DataService(client)
    val result = service.processData()
    
    result shouldBe listOf("A", "B", "C")
    coVerify { client.fetchData() }
}

고급 기능

// 1. Spy (부분 모킹)
@Test
fun `실제 객체 부분 모킹`() {
    val service = spyk(UserService())
    
    every { service.validate(any()) } returns true
    // 나머지 메서드는 실제 구현 사용
    
    service.create("테스트") shouldNotBe null
}

// 2. Capturing (인자 캡처)
@Test
fun `메서드 인자 캡처`() {
    val repository = mockk<UserRepository>()
    val slot = slot<User>()
    
    every { repository.save(capture(slot)) } returns Unit
    
    val service = UserService(repository)
    service.create("김코틀린")
    
    slot.captured.name shouldBe "김코틀린"
}

// 3. Relaxed Mock (자동 기본값)
@Test
fun `Relaxed 모드`() {
    val repository = mockk<UserRepository>(relaxed = true)
    // 모든 메서드가 기본값 반환 (설정 불필요)
    
    repository.findAll() // 빈 리스트 반환
    repository.count() // 0 반환
}

5️⃣ Exposed - JetBrains의 SQL DSL

🎯 왜 Exposed인가?

JetBrains가 만든 코틀린 SQL 라이브러리!

• JPA 없이 타입 세이프 SQL
• DSL과 DAO 패턴 모두 지원
• 트랜잭션 관리 간편

💻 실제 사용법

// 테이블 정의
object Users : IntIdTable() {
    val name = varchar("name", 50)
    val email = varchar("email", 100).uniqueIndex()
    val age = integer("age")
}

// 사용
class UserService {
    fun createUser(name: String, email: String, age: Int) = transaction {
        Users.insert {
            it[Users.name] = name
            it[Users.email] = email
            it[Users.age] = age
        }
    }
    
    fun findAdults() = transaction {
        Users.select { Users.age greaterEq 18 }
            .map { 
                User(
                    it[Users.id].value,
                    it[Users.name],
                    it[Users.email],
                    it[Users.age]
                )
            }
    }
}

🏢 실제 도입 현황

검증된 도입 사례

• Spoqa: Kotlin JDSL 마이그레이션 성공 사례
• LINE: 자체 개발 라이브러리 내부 활용
• JetBrains: Exposed를 다수 프로젝트에 사용

커뮤니티 동향

• 오픈소스: GitHub에서 1,000+ 프로젝트 사용
• 스타트업: Spring Boot + Kotlin 조합으로 확산
• 개발자: QueryDSL 대안으로 관심 증가

📊 라이브러리 특성 비교

라이브러리	주요 강점	러닝 커브	생태계
JDSL	메타모델 불필요	⭐⭐⭐	LINE 지원
Komapper	컴파일 타임 검증	⭐⭐⭐⭐	활발한 개발
Exposed	JetBrains 품질	⭐⭐	안정적
Kotest	다양한 스펙	⭐⭐⭐	큰 커뮤니티
MockK	코틀린 네이티브	⭐⭐	표준 도구

🚀 마이그레이션 가이드

QueryDSL → JDSL

// Before (QueryDSL)
queryFactory
    .selectFrom(QUser.user)
    .where(QUser.user.age.gt(18))
    .fetch()

// After (JDSL)
findAll {
    select(entity(User::class))
    from(entity(User::class))
    where(col(User::age).gt(18))
}

JUnit → Kotest

// Before (JUnit)
@Test
fun testSomething() {
    assertEquals(2, 1 + 1)
}

// After (Kotest)
test("1 + 1 = 2") {
    (1 + 1) shouldBe 2
}

Mockito → MockK

// Before (Mockito)
when(repository.findById(1L)).thenReturn(user)

// After (MockK)
every { repository.findById(1L) } returns user

💭 마무리

2025년, 아직도 자바 라이브러리만 쓰고 계신가요?

코틀린의 진정한 매력은 코틀린을 위해 만들어진 라이브러리를 쓸 때 빛납니다.

특히 QueryDSL처럼 유지보수가 중단된 라이브러리를 계속 쓸 이유는 없습니다.
JDSL이나 Komapper로 갈아타면 더 간결하고 빠른 코드를 작성할 수 있습니다.

여러분은 어떤 라이브러리를 선택하실 건가요? 댓글로 경험을 공유해주세요! 🚀

---

이 글이 도움이 되셨다면 좋아요와 공유 부탁드립니다! ❤️

🔗 참고 자료

• Kotlin JDSL 공식 문서
• Komapper 가이드
• Kotest 공식 사이트
• MockK 문서
• JetBrains 코틀린 블로그