/ /

KMongo에서 마이그레이션

개요

이 페이지에는 공식 MongoDB 코틀린 (Kotlin) ) 드라이버 와 커뮤니티에서 개발한 KMongo 운전자 차이점에 대한 대부분의 높은 수준의 비교가 포함되어 있습니다. 이 페이지를 사용하여 더 이상 사용되지 않는 KMongo 운전자 에서 공식 MongoDB 코틀린 (Kotlin) 드라이버 로 마이그레이션 위해 수행해야 하는 변경 사항을 확인할 수 있습니다.

KMongo 는 코틀린 (Kotlin) 애플리케이션에서 MongoDB 로 작업하기 위해 인기 있는 커뮤니티 개발 라이브러리입니다. 코틀린 (Kotlin) Community의 요구 사항을 제공 위해 공식 코틀린 (Kotlin) 운전자 생성되기 전에 생성된 Java 운전자 감싸는 래퍼입니다.

중요

2023년 7월부터 KMongo는 사용 중단된 것으로 표시됩니다.

MongoDB 코틀린 드라이버는 공식적으로 지원되고 유지 관리되는 코틀린용 MongoDB 드라이버입니다. 이 드라이버는 MongoDB 팀에서 개발했습니다.

두 드라이버 모두 동기 및 비동기 작업을 지원 하지만 이 페이지의 예제에서는 비동기 코루틴 기반 작업을 사용합니다.

KMongo와 코틀린 (Kotlin) 드라이버 의 차이점

코틀린 (Kotlin) 운전자 코틀린 (Kotlin) 의 공식 MongoDB 운전자 입니다. MongoDB 팀 이 개발했으며 코틀린 (Kotlin) 애플리케이션이 MongoDB 에 연결하고 데이터로 작업할 수 있는 네이티브 API 제공합니다. MongoDB Java 드라이버를 래핑하여 구현됩니다.

중요

2023년 7월부터 KMongo는 사용 중단된 것으로 표시됩니다.

코틀린(Kotlin) 드라이버는 사용자에게 공식적으로 지원되는 드라이버를 제공하기 위해 KMongo의 창시자 줄리엔 뷰레(Julien 뷰레)와 협업하여 개발되었습니다.

공식 Kotlin 드라이버와 KMongo는 일반적으로 유사한 API를 사용합니다. Kotlin 드라이버와 KMongo 간의 주목할 만한 유사점은 다음과 같습니다.

동기 및 코루틴 기반 작업 지원
데이터 클래스를 사용하여 MongoDB 문서 표현 지원
KotlinX 직렬화 지원
MongoDB CRUD API 및 집계 API 지원

공식 Kotlin 드라이버와 KMongo는 유사하지만 몇 가지 주요 차이점이 있습니다.

공식 운전자 Reactor, rxjava,2 잭슨 또는 GSON에대한 지원 내장 있지 않습니다.
공식 드라이버는 MongoDB Shell 명령을 지원하지 않습니다 .

MongoDB cluster에 연결

두 드라이버 모두 Kotlin 애플리케이션에서 MongoDB cluster에 연결하고 통신할 수 있습니다.

MongoDB 코틀린 (Kotlin) 드라이버 사용하여 MongoDB cluster 에 연결하려면 다음을 수행합니다.

import com.mongodb.kotlin.client.coroutine.MongoClient
data class Jedi(val name: String, val age: Int)
// Replace the placeholder with your MongoDB deployment's connection string
val uri = CONNECTION_STRING_URI_PLACEHOLDER
val mongoClient = MongoClient.create(uri)
val database = mongoClient.getDatabase("test")
// Get a collection of documents of type Jedi
val collection = database.getCollection<Jedi>("jedi")

자세한 내용은 MongoDB에 연결 설명서를 참조하세요.

코루틴과 함께 KMongo를 사용하여 MongoDB cluster 에 연결하려면 다음을 수행합니다.

import org.litote.kmongo.reactivestreams.*
import org.litote.kmongo.coroutine.*
data class Jedi(val name: String, val age: Int)
// Get new MongoClient instance using coroutine extension
val client = KMongo.createClient().coroutine
val database = client.getDatabase("test")
// Get a collection of documents of type Jedi
val col = database.getCollection<Jedi>()

MongoDB 코틀린 (Kotlin) 드라이버 와 달리 KMongo는 데이터 클래스 이름에서 컬렉션 이름을 유추할 수 있습니다.

CRUD 및 애그리게이션

두 드라이버 모두 모든 MongoDB CRUD API 및 애그리게이션 작업을 지원합니다.

팁

KMongo에서 사용할 수 있는 인픽스 표기법을 사용하여 쿼리 필터를 구성하는 데 익숙하다면 이 표기법을 사용하여 mongodb-driver-kotlin-extensions 패키지 의 확장 메서드를 사용하여 공식 코틀린 (Kotlin) 운전자 에서 필터를 만들 수도 있습니다. Kotlin Driver Extensions 탭 선택하면 코틀린 (Kotlin) 운전자 에서 이 쿼리 구문을 사용하는 예시 볼 수 있습니다.

MongoDB 코틀린 (Kotlin) 드라이버 모든 기본 CRUD 작업을 위한 함수도 제공합니다.

// Insert a document
val jedi = Jedi("Luke Skywalker", 19)
collection.insertOne(jedi)
// Find a document
val luke = collection.find(Jedi::name.name, "Luke Skywalker")
val jedis = collection.find(lt(Jedi::age.name, 30)).toList()
// Update a document
val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
val update = Updates.set(Jedi::age.name, 20)
collection.updateOne(filter, update)
// Delete a document
val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
collection.deleteOne(filter)

aggregate() 메서드와 pipeline 함수를 사용하여 집계 파이프라인을 빌드 할 수 있습니다.

data class Results(val avgAge: Double)
val resultsFlow = collection.aggregate<Results>(
    listOf(
      Aggregates.match(Filters.ne(Jedi::name.name, "Luke Skywalker")),
      Aggregates.group("\$${Jedi::name.name}",
          Accumulators.avg("avgAge", "\$${Jedi::age.name}"))
    )
)
resultsFlow.collect { println(it) }

자세한 내용은 CRUD 작업 및 애그리게이션 문서를 참조하세요.

mongodb-driver-kotlin-extensions 라이브러리의 빌더 API 사용하여 데이터 클래스 속성을 통해 직접 쿼리 필터 및 집계 파이프라인 단계 만들 수 있습니다. 이 라이브러리에서는 중위 표기법을 사용하여 쿼리를 만들 수도 있습니다.

import com.mongodb.kotlin.client.model.Filters.eq
import com.mongodb.kotlin.client.model.Filters.lt
import com.mongodb.kotlin.client.model.Updates.set
data class Jedi(val name: String, val age: Int)
// Find documents
val luke = collection.find(Jedi::name eq "Luke Skywalker")
val jedis = collection.find(Jedi::age lt 30)).toList()
// Update a document
val filter = Jedi::name eq "Luke Skywalker"
val update = Jedi::age.name set 20
collection.updateOne(filter, update)
// Delete a document
val filter = Jedi::name eq "Luke Skywalker"
collection.deleteOne(filter)

모든 빌더 클래스를 사용하는 자세한 내용과 예제를 학습 데이터 클래스와 함께 빌더 사용 가이드 참조하세요.

KMongo는 모든 기본 CRUD 작업을 위한 함수를 제공합니다.

// Insert a document
val jedi = Jedi("Luke Skywalker", 19)
col.insertOne(jedi)
// Find a document
val luke = col.findOne(Jedi::name eq "Luke Skywalker")
val jedis = col.find(Jedi::age lt 30).toList()
// Update a document
col.updateOne(Jedi::name eq "Luke Skywalker", setValue(Jedi::age, 20))
// Delete a document
col.deleteOne(Jedi::name eq "Luke Skywalker")

집계 파이프라인은 aggregate 메서드와 pipeline 함수를 사용하여 구축할 수 있습니다.

val avgAge = collection.aggregate<Double>(
    pipeline(
        match(Jedi::name ne "Luke Skywalker"),
        group(Jedi::name, avg(Jedi::age))
    )
).toList()

사용 가능한 메서드에 대한 자세한 내용은 확장 프로그램 개요 KMongo 설명서를 참조하세요.

쿼리 구성

두 드라이버 모두 속성 참조를 사용하여 형식 안정 쿼리를 지원합니다.

팁

MongoDB 코틀린 (Kotlin) 드라이버 빌더 API 사용하여 쿼리를 구성합니다. 또는 Document 클래스를 사용할 수 있습니다.

data class Person(val name: String, val email: String, val gender: String, val age: Int)
data class Results(val email: String)
val collection = database.getCollection<Person>("people")
// Using Builders
val filter = and(eq("gender", "female"), gt("age", 29))
val projection = fields(excludeId(), include("email"))
val results = collection.find<Results>(filter).projection(projection)
// Using Document class
val filter = Document().append("gender", "female").append("age", Document().append("\$gt", 29))
val projection = Document().append("_id", 0).append("email", 1)
val results = collection.find<Results>(filter).projection(projection)

KMongo 문자열 쿼리를 코틀린(Kotlin) 드라이버에 매핑하려면 JsonObject 클래스를 사용할 수 있습니다.

val query = JsonObject("{\"name\": \"Gabriel Garc\\u00eda M\\u00e1rquez\"}")
val jsonResult = collection.find(query).firstOrNull()

자세한 내용은 다음 Kotlin 드라이버 문서를 참조하세요.

빌더
문서 가이드
JsonObject API 문서

mongodb-driver-kotlin-extensions 라이브러리의 빌더 API 사용하여 데이터 클래스 속성에 대해 직접 쿼리를 구성할 수 있습니다. 이 라이브러리에서는 중위 표기법을 사용하여 쿼리를 만들 수도 있습니다.

import com.mongodb.kotlin.client.model.Filters.eq
import com.mongodb.kotlin.client.model.Filters.and
import com.mongodb.kotlin.client.model.Filters.gt
import com.mongodb.kotlin.client.model.Projections.excludeId
import com.mongodb.kotlin.client.model.Projections.fields
import com.mongodb.kotlin.client.model.Projections.include
data class Person(val name: String, val gender: String, val age: Int)
data class Result(val name: String)
val collection = database.getCollection<Person>("people")
// Infix Notation Query
val filter = (Person::gender eq "female") and (Person::age gt 29))
val projection = fields(excludeId(), include(Person::name))
val results = collection.find<Result>(filter).projection(projection)

모든 빌더 클래스를 사용하는 자세한 내용과 예제를 학습 데이터 클래스와 함께 빌더 사용 가이드 참조하세요.

KMongo를 사용하면 컬렉션 의 객체를 나타내는 데이터 클래스의 속성 참조와 라이브러리에서 제공하는 중위 연산자를 사용하여 쿼리를 만들 수 있습니다.

data class Jedi(val name: String)
val yoda = col.findOne(Jedi::name eq "Yoda")
// Compile error (2 is not a String)
val error = col.findOne(Jedi::name eq 2)
// Use property reference with instances
val yoda2 = col.findOne(yoda::name regex "Yo.*")

KMongo는 쿼리 언어로 쿼리를 구성할 수 있는 쿼리도 지원합니다.string MongoDB

import org.litote.kmongo.MongoOperator.lt
import org.litote.kmongo.MongoOperator.match
import org.litote.kmongo.MongoOperator.regex
import org.litote.kmongo.MongoOperator.sample
val yoda = col.findOne("{name: {$regex: 'Yo.*'}}")!!
val luke = col.aggregate<Jedi>("""[ {$match:{age:{$lt : ${yoda.age}}}},
                                    {$sample:{size:1}}
                                ]""").first()

자세한 내용은 다음 KMongo 설명서를 참조하세요.

데이터 유형 지정

두 드라이버 모두 코틀린 (Kotlin) 데이터 클래스와 Document 클래스를 사용하여 MongoDB 컬렉션 에 저장된 데이터를 모델링할 수 있도록 지원 . Document 클래스를 사용하면 MongoDB 컬렉션 에 표시된 데이터를 유연한 형식으로 모델링할 수 있습니다.

데이터 클래스와 Document 클래스를 사용하여 MongoDB 코틀린 (Kotlin) 드라이버 로 데이터를 모델링할 수 있습니다.

// With data class
data class Movie(val title: String, val year: Int, val rating: Float)
val dataClassCollection = database.getCollection<Movie>("movies")
val movieDataClass = dataClassCollection.findOneOrNull()
val movieNameDataClass = movieDataClass.title
// With Document class
val documentCollection = database.getCollection<Movie>("movies")
val movieDocument = documentCollection.findOneOrNull()
val movieTitleDocument = movieDocument.getString("title")

데이터 클래스와 Document 클래스를 사용하여 KMongo에서 데이터를 모델링할 수 있습니다.

// With data class
data class Movie(val title: String, val year: Int, val rating: Float)
val collection = database.getCollection<Movie>("movies")
val movieDataClass = dataClassCollection.findOne()
val movieNameDataClass = movieDataClass.title
// With Document class
val documentCollection = database.getCollection("movies")
val movieDocument = documentCollection.findOne()
val movieTitleDocument = movieDocument.getString("title")

데이터 직렬화

두 드라이버 모두 Kotlin의 데이터 객체와 BSON 간의 직렬화 및 역직렬화를 지원합니다.

자동 데이터 클래스 코덱과 kotlinx.serialization 라이브러리를 모두 사용하여 코틀린 (Kotlin) 운전자 에서 데이터 클래스를 직렬화할 수 있습니다. 운전자 BSON 데이터에 대한 코틀린 (Kotlin) 객체의 직렬화를 처리하는 효율적인 Bson 직렬 변환기를 제공합니다.

@Serializable
data class LightSaber(
    @SerialName("_id") // Use instead of @BsonId
    @Contextual val id: ObjectId?,
    val color: String,
    val qty: Int,
    @SerialName("brand")
    val manufacturer: String = "Acme" // Use instead of @BsonProperty
)

자세한 내용은 코틀린( Kotlin) 직렬화 문서를 참조하세요.

Document 클래스를 사용하여 컬렉션을 나타내는 경우 .toJson() 메서드를 사용하여 컬렉션을 JSON 및 EJSON으로 직렬화할 수 있습니다.

val document = Document("_id", 1).append("color", "blue")
// Serialize to JSON
document.toJson()
// Serialize to EJSON
val settings = JsonWriterSettings.builder().outputMode(JsonMode.STRICT).build()
val json = doc.toJson(settings)

Document 클래스로 데이터를 직렬화하는 방법에 대해 자세히 알아보려면 문서 데이터 형식 - 확장 JSON 문서를 참조하세요.

다음 직렬화 라이브러리를 사용하여 KMongo에서 데이터를 직렬화할 수 있습니다.

Jackson (기본값)
POJO Codec engine
kotlinx.serialization

// Using KotlinX Serialization
@Serializable
data class Data(@Contextual val _id: Id<Data> = newId())
val json = Json { serializersModule = IdKotlinXSerializationModule }
val data = Data()
val json = json.encodeToString(data)

KMongo 직렬화 메서드에 대해 자세히 학습하려면 객체 매핑 KMongo 설명서를 참조하세요.

동기 및 비동기 지원

두 드라이버 모두 동기 및 비동기 작업을 지원합니다.

MongoDB 코틀린 (Kotlin) 드라이버 동기 및 비동기 작업을 위한 별도의 라이브러리도 있습니다. 그러나 코틀린 (Kotlin) 운전자 비동기 패러다임으로서의 코루틴 지원 만 내장 있습니다. MongoDB 코틀린 (Kotlin) 드라이버 현재 Reactive Streams, Reactor 또는 RxJava2와 같은 다른 비동기 패러다임에 대한 지원 제공하지 않습니다.

드라이버	패키지
동기화	`com.mongodb.kotlin.client`
코루틴	`com.mongodb.kotlin.client.coroutine`

KMongo와 달리 비동기 코드를 작성하려는 경우 관련 패키지만 가져오면 됩니다.

동기 코드를 작성하려면 다음을 수행합니다.

import com.mongodb.kotlin.client.MongoClient
// Instantiate your collection
data class Jedi(val name: String, val age: Int)
val uri = "<your-connection-string">
val mongoClient = MongoClient.create(uri)
val database = mongoClient.getDatabase("test")
val collection = database.getCollection<Jedi>("jedi")
// Synchronous operations
val jedi = Jedi("Luke Skywalker", 19)
collection.insertOne(jedi)

비동기 코루틴 코드를 작성하려면 다음을 수행하세요.

import com.mongodb.kotlin.client.coroutine.MongoClient
// Instantiate your collection
data class Jedi(val name: String, val age: Int)
val uri = "<your-connection-string">
val mongoClient = MongoClient.create(uri)
val database = mongoClient.getDatabase("test")
val collection = database.getCollection<Jedi>("jedi")
runBlocking {
  // Async operations
  val jedi = Jedi("Luke Skywalker", 19)
  collection.insertOne(jedi)
}

KMongo에는 주요 기능을 갖춘 핵심 라이브러리 org.litote.kmongo:kmongo 와 핵심 라이브러리에 비동기 지원을 제공하는 별도의 컴패니언 라이브러리가 있습니다.

KMongo는 다음과 같은 비동기 패러다임을 지원합니다.

비동기 스타일	패키지
reactive streams	`org.litote.kmongo:kmongo-async`
코루틴	`com.mongodb.kotlin.client.coroutine` 개인정보 정책에 `org.litote.kmongo.coroutine`
Reactor	`org.litote.kmongo:kmongo-reactor`
RxJava2	`org.litote.kmongo:kmongo-rxjava2`

KMongo로 동기 코드를 쓰기 (write) 하려면 다음을 수행합니다.

import org.litote.kmongo.*
// Instantiate your collection
data class Jedi(val name: String, val age: Int)
val client = KMongo.createClient()
val database = client.getDatabase("test")
val col = database.getCollection<Jedi>()
// Synchronous operations
col.insertOne(Jedi("Luke Skywalker", 19))
val yoda : Jedi? = col.findOne(Jedi::name eq "Yoda")

KMongo로 비동기 코루틴 코드를 작성하려면 다음을 수행하세요.

import org.litote.kmongo.reactivestreams.*
import org.litote.kmongo.coroutine.*
// Instantiate your collection
data class Jedi(val name: String, val age: Int)
val client = KMongo.createClient()
val database = client.getDatabase("test")
val col = database.getCollection<Jedi>()
runBlocking {
  // Async operations
  col.insertOne(Jedi("Luke Skywalker", 19))
  val yoda : Jedi? = col.findOne(Jedi::name eq "Yoda")
}

자세한 학습 은 KMongo 설명서의 빠른 시작을 참조하세요.

다음 단계는 무엇인가요?

이제 KMongo와 MongoDB 코틀린(Kotlin) 드라이버의 차이점에 대해 알아보았으니, KMongo 코틀린(Kotlin) 드라이버 사용 시작하기 위한 빠른 시작 을 참조하세요.

돌아가기

릴리스 노트

업그레이드