문서 메뉴
문서 홈
/
언어
/
Kotlin
/
Kotlin 코루틴

KMongo에서 마이그레이션

이 페이지의 내용

  • 개요
  • MongoDB cluster에 연결
  • CRUD 및 애그리게이션
  • 쿼리 구성
  • 데이터 유형 지정
  • 데이터 직렬화
  • 동기 및 비동기 지원
  • 다음 단계는 무엇인가요?

개요

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

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

중요

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

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

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

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 클러스터에 연결하려면 다음을 수행합니다.

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 및 애그리게이션 작업을 지원합니다.

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

// Insert a document
  val jedi =a 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 작업 및 애그리게이션 문서를 참조하세요.

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 드라이버 문서를 참조하세요.

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는 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 collection에 저장된 데이터를 모델링할 수 있도록 지원합니다. Document 클래스를 사용하면 MongoDB collection에 표시되는 데이터를 유연한 형식으로 모델링할 수 있습니다.

데이터 클래스와 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 =a 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 =a 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 and org.litote.kmongo.coroutine
원자로
org.litote.kmongo:kmongo-reactor
RxJava2
org.litote.kmongo:kmongo-rxjava2

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

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) 드라이버 사용 시작하기 위한 빠른 시작 을 참조하세요.

돌아가기

호환성

다음

드라이버 아티팩트 서명 유효성 검사

이 페이지의 내용