코틀린(Kotlin) 직렬화

개요

애플리케이션 에서 코틀린 (Kotlin) 객체를 직렬화 및 역직렬화할 때 kotlinx.serialization 라이브러리를 사용할 수 있습니다.

이 운전자 는 @Serializable 주석으로 표시된 클래스와 함께 사용할 수 있는 효율적인 Bson 직렬 변환기를 제공하여 코틀린( 코틀린 (Kotlin) ) 객체의 BSON 데이터 직렬화를 처리하다 합니다.

코틀린 (Kotlin) 직렬화 Json 라이브러리를 사용할 수 있지만 Json 직렬 변환기는 ObjectId 와 같은 BSON 값 유형을 직접 지원 하지 않습니다 . BSON 과 JSON 간의 변환을 처리하다 할 수 있는 사용자 지정 직렬 변환기를 제공해야 합니다.

기본값, null을 인코딩하고 클래스 판별자를 정의하는 구성이 있는 사용자 지정 코덱을 지원 하려면 bson-kotlinx 라이브러리를 설치하는 것이 좋습니다.

프로젝트에 직렬화 종속성 추가

애플리케이션 에서 데이터를 직렬화 및 역직렬화하려면 공식 코틀린 (Kotlin) 직렬화 라이브러리인 kotlinx.serialization 을 설치해야 합니다. 이 라이브러리에 학습 보려면 kotlinx.serialization Github 리포지토리 를 참조하세요.

다음 탭에서 선택하여 Gradle 또는 Maven 를 사용하여 프로젝트 에 직렬화 종속성을 추가하는 방법을 확인합니다.

implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1")
implementation("org.mongodb:bson-kotlinx:5.2.0")

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-serialization-core</artifactId>
    <version>1.5.1</version>
</dependency>
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>bson-kotlinx</artifactId>
    <version>5.2.0</version>
</dependency>

데이터 클래스에 어노테이션을 첨가합니다.

클래스를 직렬화 가능으로 선언하려면 @Serializable 주석으로 코틀린 (Kotlin) 데이터 클래스에 주석을 추가합니다.

데이터 클래스를 직렬화 가능으로 표시한 후 다른 데이터 클래스를 사용하는 것처럼 코드에서 사용할 수 있습니다. 코틀린 동기 (Kotlin Sync) 운전자 와 코틀린 (Kotlin) 직렬화 프레임워크 는 BSON 직렬화 및 역직렬화를 처리하다 합니다.

이 예시 에서는 다음 주석이 있는 샘플 데이터 클래스를 보여줍니다.

• @Serializable: 클래스를 직렬화 가능으로 표시합니다.

• @SerialName: BSON 문서 에서 id 및 manufacturer 속성의 이름을 지정합니다. 이 주석은 직렬화 가능 클래스에서 지원되지 않는 @BsonId 및 @BsonProperty 주석 대신 사용할 수 있습니다.

• @Contextual: 내장 ObjectIdSerializer 을(를) 사용하도록 BSON id 속성 을 표시합니다. 이 주석은 운전자 가 BSON types를 올바르게 직렬화하는 데 필요합니다.

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

직렬화 가능 클래스 및 사용 가능한 주석에 학습 보려면 직렬화 가능 클래스를 kotlinx.serialization 참조하세요. 라이브러리 문서에서 확인 가능합니다.

object InstantAsBsonDateTime : KSerializer<Instant> {
    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("InstantAsBsonDateTime", PrimitiveKind.LONG)
    override fun serialize(encoder: Encoder, value: Instant) {
        when (encoder) {
            is BsonEncoder -> encoder.encodeBsonValue(BsonDateTime(value.toEpochMilli()))
            else -> throw SerializationException("Instant is not supported by ${encoder::class}")
        }
    }
    override fun deserialize(decoder: Decoder): Instant {
        return when (decoder) {
            is BsonDecoder -> Instant.ofEpochMilli(decoder.decodeBsonValue().asDateTime().value)
            else -> throw SerializationException("Instant is not supported by ${decoder::class}")
        }
    }
}

@Serializable
data class PaintOrder(
    val color: String,
    val qty: Int,
    @Serializable(with = InstantAsBsonDateTime::class)
    val orderDate: Instant,
)

직렬 변환기 구성을 사용자 지정합니다.

org.bson.codecs.kotlinx 패키지 의 KotlinSerializerCodec 클래스를 사용하여 @Serializable 데이터 클래스에 대한 코덱을 만들고 운전자 가 MongoDB 에 저장하는 내용을 사용자 지정할 수 있습니다.

BsonConfiguration 클래스를 사용하여 기본값을 인코딩할지, null을 인코딩할지 또는 클래스 판별자를 정의할지 여부를 포함할 수 있는 구성을 정의합니다.

사용자 지정 코덱을 만들려면 프로젝트 에 bson-kotlinx 종속성이 있어야 합니다. 설치 지침은 이 가이드 의 프로젝트에 직렬화 종속성 추가 섹션을 참조하세요.

KotlinSerializerCodec.create() 메서드 를 사용하여 코덱을 정의할 수 있습니다. 메서드를 사용한 다음 레지스트리에 코덱을 추가할 수 있습니다.

val myCustomCodec = KotlinSerializerCodec.create<PaintOrder>(
    bsonConfiguration = BsonConfiguration(encodeDefaults = false)
)
val registry = CodecRegistries.fromRegistries(
    CodecRegistries.fromCodecs(myCustomCodec), collection.codecRegistry
)

다형성 직렬화

코틀린 동기 (Kotlin Sync) 운전자 는 기본적으로 다형성 클래스의 직렬화 및 역직렬화를 지원합니다. 봉인된 인터페이스와 해당 인터페이스를 상속하는 데이터 클래스를 @Serializable 주석으로 표시하면 운전자 는 KSerializer 구현 을 사용하여 BSON 과의 유형 변환을 처리하다 합니다.

다형성 데이터 클래스의 인스턴스 를 MongoDB 에 삽입하면 운전자 는 판별자 필드 인 _t 필드 를 추가합니다. 이 필드 의 값은 데이터 클래스 이름입니다.

@Serializable
sealed interface Person {
    val name: String
}
@Serializable
data class Student(
    @Contextual
    @SerialName("_id")
    val id: ObjectId,
    override val name: String,
    val grade: Int,
) : Person
@Serializable
data class Teacher(
    @Contextual
    @SerialName("_id")
    val id: ObjectId,
    override val name: String,
    val department: String,
) : Person

val collection = database.getCollection<Person>("school")
val teacherDoc = Teacher(ObjectId(), "Vivian Lee", "History")
val studentDoc = Student(ObjectId(), "Kate Parker", 10)
collection.insertOne(teacherDoc)
collection.insertOne(studentDoc)
println("Retrieving by using data classes")
val resultTeacher = collection.withDocumentClass<Teacher>()
    .find(Filters.exists("department"))
    .firstOrNull()
println(resultTeacher)
val resultStudent = collection.withDocumentClass<Student>()
    .find(Filters.exists("grade"))
    .firstOrNull()
println(resultStudent)
println("\nRetrieving by using Person interface")
val resultsPerson = collection.withDocumentClass<Person>().find()
resultsPerson.forEach { result ->
    println(result)
}
println("\nRetrieving as Document type")
val resultsDocument = collection.withDocumentClass<Document>().find()
resultsDocument.forEach { result ->
    println(result)
}

Retrieving by using data classes
Teacher(id=..., name=Vivian Lee, department=History)
Student(id=..., name=Kate Parker, grade=10)
Retrieving by using Person interface
Teacher(id=..., name=Vivian Lee, department=History)
Student(id=..., name=Kate Parker, grade=10)
Retrieving as Document type
Document{{_id=..., _t=Teacher, name=Vivian Lee, department=History}}
Document{{_id=..., _t=Student, name=Kate Parker, grade=10}}

날짜 및 시간 직렬화

이 섹션에서는 코틀린 (Kotlin) 직렬화를 사용하여 날짜 및 시간 유형으로 작업하는 방법에 학습 수 있습니다.

implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-datetime-jvm</artifactId>
    <version>0.6.1</version>
</dependency>

@Serializable
data class Appointment(
    val name: String,
    @Contextual val date: LocalDate,
    val time: LocalTime,
)

val collection = database.getCollection<Appointment>("appointments")
val apptDoc = Appointment(
    "Daria Smith",
    LocalDate(2024, 10, 15),
    LocalTime(hour = 11, minute = 30)
)
collection.insertOne(apptDoc)

{
  "_id": ...,
  "name": "Daria Smith",
  "date": {
    "$date": "2024-10-15T00:00:00.000Z"
  },
  "time": "11:30",
}