Jakie mechanizmy są używane do serializacji danych w Kotlin?

W Kotlinie główne mechanizmy serializacji danych to:

1. Biblioteka kotlinx.serialization:

   • Oficjalna wieloplatformowa biblioteka od JetBrains.
   • Obsługuje różne formaty: JSON, Protobuf, CBOR, YAML.
   • Opiera się na adnotacjach i wtyczce kompilatora, co pozwala generować kod serializacji podczas kompilacji.
   • Zapewnia automatyczną serializację klas danych.

   Przykład użycia:

   import kotlinx.serialization.Serializable
   import kotlinx.serialization.json.Json
   
   @Serializable
   data class User(val name: String, val age: Int)
   
   fun main() {
       val user = User("Alice", 30)
       val jsonString = Json.encodeToString(User.serializer(), user) // Serializacja do JSON
       println(jsonString)
       val decodedUser = Json.decodeFromString(User.serializer(), jsonString) // Deserializacja z JSON
       println(decodedUser)
   }
   

2. Jackson:

   • Bardzo popularna biblioteka w Javie, szeroko używana także z Kotlinem.
   • Wymaga dodania modułu jackson-module-kotlin dla obsługi konstrukcji specyficznych dla Kotlina (np. serializacja klas danych z domyślnymi parametrami konstruktora).
   • Obsługuje wiele formatów: JSON, XML, YAML i inne.
   • Działa na podstawie refleksji.

   Przykład użycia z modułem Kotlin:

   import com.fasterxml.jackson.annotation.JsonProperty
   import com.fasterxml.jackson.databind.ObjectMapper
   import com.fasterxml.jackson.module.kotlin.KotlinModule
   import com.fasterxml.jackson.module.kotlin.readValue
   
   data class Product(
       @JsonProperty("id") val id: Int,
       @JsonProperty("name") val name: String,
       @JsonProperty("price") val price: Double
   )
   
   fun main() {
       val mapper = ObjectMapper().registerModule(KotlinModule())
       val product = Product(1, "Laptop", 1200.0)
       val jsonString = mapper.writeValueAsString(product) // Serializacja do JSON
       println(jsonString)
       val decodedProduct = mapper.readValue<Product>(jsonString) // Deserializacja z JSON
       println(decodedProduct)
   }
   

3. Gson:

   • Biblioteka od Google.
   • Również popularna, szczególnie w rozwoju Androida.
   • Działa na podstawie refleksji.
   • Obsługuje tylko JSON.
   • Może wymagać bardziej jawnego określenia typów do deserializacji kolekcji lub generyków.

   Przykład użycia:

   import com.google.gson.Gson
   import com.google.gson.annotations.SerializedName
   
   data class Item(
       @SerializedName("item_id") val itemId: String,
       @SerializedName("description") val description: String
   )
   
   fun main() {
       val gson = Gson()
       val item = Item("SKU123", "Wireless Mouse")
       val jsonString = gson.toJson(item) // Serializacja do JSON
       println(jsonString)
       val decodedItem = gson.fromJson(jsonString, Item::class.java) // Deserializacja z JSON
       println(decodedItem)
   }
   

4. Kryo:

   • Wydajny framework do binarnej serializacji obiektów.
   • Często używany w scenariuszach o wysokiej wydajności, takich jak cache'owanie czy komunikacja sieciowa, gdzie rozmiar i szybkość serializacji są istotne.
   • Może wymagać rejestracji klas.

   Przykład (konceptualny, bez pełnej konfiguracji):

   // Przykład na podstawie Kryo
   import com.esotericsoftware.kryo.Kryo
   import com.esotericsoftware.kryo.io.Input
   import com.esotericsoftware.kryo.io.Output
   import java.io.FileInputStream
   import java.io.FileOutputStream
   
   data class Event(val id: Int, val timestamp: Long, val message: String)
   
   fun main() {
       val kryo = Kryo()
       kryo.register(Event::class.java) // Rejestracja klasy
   
       val event = Event(42, System.currentTimeMillis(), "Coś się stało!")
   
       // Serializacja do pliku
       Output(FileOutputStream("event.bin")).use { output ->
           kryo.writeObject(output, event)
       }
   
       // Deserializacja z pliku
       Input(FileInputStream("event.bin")).use { input ->
           val decodedEvent = kryo.readObject(input, Event::class.java)
           println(decodedEvent)
       }
   }
   

Wybór mechanizmu zależy od wymagań projektu: wieloplatformowość, format danych, wydajność, rozmiar bibliotek i wygoda użycia. kotlinx.serialization jest zalecany dla nowych projektów Kotlin, szczególnie wieloplatformowych. Jackson i Gson pozostają popularne, zwłaszcza przy integracji z istniejącymi ekosystemami Java. Kryo jest używane w specyficznych, wydajnościowych zadaniach.