【Kotlin】kotlinx.serialization Vs Gson

1. 簡介

• kotlinx.serialization：介紹它是 Kotlin 官方提供的序列化庫，支持 JSON 和其他格式。
• Gson：介紹它是 Google 開發的 Java 序列化庫，用於將 Java 對象轉換為 JSON，反之亦然。

• 範例程式碼：

  // kotlinx.serialization example
  @Serializable
  data class User(val name: String, val age: Int)
  

• // Gson example
  data class User(val name: String, val age: Int)
  

• 說明： kotlinx.serialization 使用 @Serializable 註解來標記可序列化的類，而 Gson 則不需要特定註解（除非需要特殊處理）。

2. 設計理念

• kotlinx.serialization：設計為 Kotlin 專用，強調與 Kotlin 語言特性的緊密集成（例如 data classes、sealed classes）。
• Gson：設計為通用的 Java 庫，支持多種 Java 對象類型。

• 範例程式碼：

  // kotlinx.serialization
  val jsonStr = Json.encodeToString(User("Alice", 25))
  println(jsonStr)  // {"name":"Alice","age":25}
  
    
  // Gson
  val gson = Gson()
  val gsonStr = gson.toJson(User("Alice", 25))
  println(gsonStr)  // {"name":"Alice","age":25}

• 說明： kotlinx.serialization 與 Kotlin 整合更緊密，直接使用 Kotlin 的標準庫方法，而 Gson 則是 Java 標準的物件-JSON 序列化工具。

3. 使用方式

• 介紹如何在兩者中實現基本的 JSON 序列化和反序列化。
• 範例程式碼：比較使用 @Serializable 註解和 Gson 的 @SerializedName 註解。
• 依賴管理：

• object Kotlin {
  	const val serializationJson 	= "org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1"
  }
  
  dependencies {
  	implementation(Kotlin.serializationJson)
  }
  
  plugins {
  	kotlin("plugin.serialization") version "2.0.0"  // 添加序列化插件
  }

• object Libraries {
  	const val gson 		= "com.google.code.gson:gson:2.10.1"
  }
  
  dependencies {
  	implementation(Libraries.gson)
  }

• 範例程式碼：

  // kotlinx.serialization
  @Serializable
  data class Product(val id: Int, val name: String)
  
  val jsonString = Json.encodeToString(Product(1, "Laptop"))
  val product = Json.decodeFromString<Product>(jsonString)
  
  

• // Gson
  data class Product(val id: Int, val name: String)
  
  val gson = Gson()
  val jsonString = gson.toJson(Product(1, "Laptop"))
  val product = gson.fromJson(jsonString, Product::class.java)
  

• 簡短說明： kotlinx.serialization 和 Gson 都可以輕鬆地進行物件與 JSON 之間的轉換，但 kotlinx.serialization 更加型別安全，避免了 Java 的類型擦除問題。

1. 類型擦除（Type Erasure）問題

• 當您呼叫 toJson(obj) 時，Gson 呼叫 obj.getClass() 來獲取要序列化的欄位資訊。同樣，您通常可以在 fromJson(json, MyClass.class) 方法中傳入 MyClass.class 物件。這對於非泛型類型的物件來說效果很好。然而，如果物件是泛型類型，那麼由於 Java 類型擦除，泛型類型資訊就會丟失。以下是說明這一點的範例：

• @Serializable
  data class People<T>(var value: T)
  @Serializable
  data class Man(val name: String)
  
     val gson = Gson()
     val people = People(Man("John"))
     gson.toJson(people) 
  
     gson.fromJson<People<Man>>(people, People::class.java) // 無法將 people.value 反序列化為 People

• 上述代碼無法將 value 解釋為 Man 類型，因為 Gson 調用 People::class.java 來獲取其類別資訊，但此方法返回原始類別，People::class.java。這意味著 Gson 無法知道這是一個 People<Man> 類型的物件，而不僅僅是普通的 People。

   

  您可以通過為您的泛型類型指定正確的參數化類型來解決這個問題。您可以使用 TypeToken 類別來實現這一點。

•    val gson = Gson()
     val people = People(Man("John"))
     val peopleType = object : TypeToken<People<Man>>() {}.type
     val gsonString = gson.toJson(people, peopleType)
     println(gsonString) //{"value":{"name":"John"}}
  
     val people2 = gson.fromJson<People<Man>>(gsonString, peopleType)
     println(people2) // People(value=Man(name=John))

•    val gson = Gson()
     val users = listOf(User("Alice",18),User("Sam",20))
     val gsonString = gson.toJson(users)
     // 序列化
     println(gsonString) // [{"name":"Alice","age":18},{"name":"Sam","age":20}]
  
     // 反序列化
     val userType = object : TypeToken<List<User>>() {}.type
  //   val users2 = gson.fromJson<List<User>>(gsonString,  List<User>::class.java)  // 無法反序列化
     val users2 = gson.fromJson<List<User>>(gsonString, userType)
     println(users2) // [User(name=Alice, age=18), User(name=Sam, age=20)]

• import com.google.gson.Gson
  import com.google.gson.GsonBuilder
  import com.google.gson.reflect.TypeToken
  
  val gson: Gson = GsonBuilder()
          .serializeNulls()
          .setLenient()
          .create()
  
      private val prettyGson: Gson = GsonBuilder()
          .setPrettyPrinting()
          .serializeNulls()
          .setLenient()
          .create()
  
      fun <T> fromJson(json: String, clazz: Class<T>): T {
          return gson.fromJson(json, clazz)
      }
  
      inline fun <reified T> fromJson(json: String): T {
          return gson.fromJson(json, object : TypeToken<T>() {}.type)
      }
  
      fun toJson(src: Any): String {
          return gson.toJson(src)
      }
  
      fun toPrettyJson(src: Any): String {
          return prettyGson.toJson(src)
      }
  //////////////////////////////////////////////////////////////
  
     val map = listOf(User("Alice", 25) ,User("John", 18))
     val userList = GsonUtil.fromJson<List<User>>(GsonUtil.toJson(map))
     println(userList) // [User(name=Alice, age=25), User(name=John, age=18)]

2. kotlinx.serialization 的型別安全

kotlinx.serialization 是 Kotlin 原生的序列化庫，它能夠利用 Kotlin 的反射和內聯函數特性在編譯時和運行時保留類型信息，避免了類型擦除問題。這意味著你可以直接在編譯期獲取類型信息，從而在運行時保留完整的類型安全性。

範例：

@Serializable
data class People<T>(var value: T)
@Serializable
data class Man(val name: String)
  
   val people = People(Man("John"))
   val jsonString = Json.encodeToString(people)
   println(jsonString) // {"value":{"name":"John"}}
   val people2 = Json.decodeFromString<People<Man>>(jsonString)
   println(people2) // People(value=Man(name=John))

在這個例子中，kotlinx.serialization 使用 decodeFromString<User>(jsonString) 方法時，直接保留了 User 類型的信息，而無需額外提供類型提示。這是因為 Kotlin 的 inline 函數和 reified 泛型可以在運行時保留類型信息。

3. 優勢和好處

• 更簡潔的代碼：由於不需要像 Java 中那樣使用 TypeToken，代碼更為簡潔。
• 避免運行時錯誤：kotlinx.serialization 在編譯期就可以捕獲到類型錯誤，減少了在運行時發生類型錯誤的風險。
• 原生支持 Kotlin 特性：kotlinx.serialization 支持 Kotlin 的數據類（data class）、密封類（sealed class）、型別別名（type alias）等，這些在序列化時都能得到更好的支持。

4. 特性比較

在 kotlinx.serialization 中，有多種設定可以控制 JSON 序列化和反序列化的行為，這些設定可以通過 Json 配置進行調整。以下是對這些設定的詳細補充說明，以及如何混合使用它們：

1. prettyPrint

• 說明：如果設置為 true，生成的 JSON 會以更具可讀性的格式進行縮排和換行。這對於需要易於閱讀和調試的 JSON 輸出非常有用。
• 預設值(false)
• 範例：

  val json = Json { prettyPrint = true }
  val data = json.encodeToString(User("Alice", 25))
  println(data) // 生成的 JSON 會換行和縮排
  
  /*
  {
      "name": "Alice",
      "age": 25
  }
  */

• val gson = GsonBuilder().setPrettyPrinting().create()
  val jsonString = gson.toJson(User("Alice", 25))
  println(jsonString)
    
  /*
  {
      "name": "Alice",
      "age": 25
  }
  */

2. isLenient

• 說明：如果設置為 true，反序列化時會允許 JSON 不符合嚴格的 JSON 標準。例如，允許非雙引號字符串、不轉義的控制字符等。
• 範例：

  val json = Json { isLenient = true }
  val user = json.decodeFromString<User>("""{"name":'Alice', "age":25}""")
  println(user)  // User(name=Alice, age=25)

•    val gson = GsonBuilder()
                 .setLenient()
                 .create()
     val reader = StringReader("{'name': 'Alice', 'age': 25}")
     val user: User = gson.fromJson(reader, User::class.java)
     println(user) // User(name=Alice, age=25)

• 用途：用於處理不符合標準的 JSON。

3. ignoreUnknownKeys

• 說明：如果設置為 true，反序列化時會忽略 JSON 中多餘的、不在 Kotlin 資料類中定義的鍵。
• 預設值(false)，多餘的、不在 Kotlin 資料類中定義的鍵，會拋出錯誤
• 範例：

  val json = Json { ignoreUnknownKeys = true }
  val data = json.decodeFromString<User>("""{"name":"Alice", "age":25, "gender":"female"}""")
  // User(name=Alice, age=25)

• // Gson 只會輸出class有的屬性，不會出現錯誤
  val gson = Gson()
     val user: User = gson.fromJson("{\"name\": \"Alice\", \"age\": 25, \"gender\": \"female\"}", User::class.java)
     println(user) // User(name=Alice, age=25)

• 用途：用於處理結構可能有變化或不完整的 JSON 資料。

4. @JsonNames

• 說明：用於指定多個 JSON 欄位名可以對應於 Kotlin 類中的同一屬性。這對於處理不同命名風格或版本兼容性非常有用。
• 範例：

  @Serializable
  data class User(
      @JsonNames("username", "user_name","uname")
      val name: String,
      val age: Int
  )
  
  val json = Json{}
    
  val User = Json.encodeToString(User("mary", 20))
  println(User) // {"name":"mary","age":20}
    
  val jsonNamesData = json.decodeFromString<User>("""{"uname":"Alice", "age":25, "gender":"female"}""")
  println(jsonNamesData) // User(name=Alice, age=25)
  

• import com.google.gson.annotations.SerializedName
  
  data class User(
      @SerializedName(value = "user_name", alternate = ["username", "userName"])
      val name: String,
      val age: Int
  )
  
  // 序列化
  val jsonString = """{"user_name": "Alice", "age": 25}"""
  val gson = Gson()
  val user: User = gson.fromJson(jsonString, User::class.java)
  println(user.name)  // Output: Alice
  
  // 反序列化
  val user = User(name = "Alice", age = 25)
  val gson = Gson()
  val jsonString = gson.toJson(user)
  println(jsonString)  // Output: {"user_name":"Alice","age":25}
  

• 用途：用於不同 JSON 格式之間的兼容性。

5. encodeDefaults

• 說明：如果設置為 true，則在序列化時會包含所有屬性，即使它們具有預設值；如果為 false，則省略具有預設值的屬性。
  預設輸出預設值(false)
• 範例：

  data class User(
     @JsonNames("username", "user_name", "uname")
     val name: String,
     val age: Int = 30
  )
  
  val json = Json { encodeDefaults = true }
  val data = json.encodeToString(User("Alice"))
  
  //    encodeDefaults = true
  //   {
  //      "name": "Alice",
  //      "age": 30
  //   }
    
  //    encodeDefaults = false (default)
  //   {
  //      "name": "Alice"
  //   }

• // 說明：Gson 不會使用 Kotlin 的預設參數值,
  // 想要預設值需要自定義序列化器
      val userSerializer = JsonSerializer<User> { src, _, _ ->
        val DEFAULT_AGE = 30
        val jsonObject = JsonObject()
        jsonObject.addProperty("name", src.name)
        if (src.age != DEFAULT_AGE) { // 檢查 age 是否為預設值
           jsonObject.addProperty("age", src.age)
        }
        jsonObject
      }
  
      // 創建 Gson 並註冊自定義序列化器
      val gson = GsonBuilder()
          .registerTypeAdapter(User::class.java, userSerializer)
          .create()
  
      val alice = User("Alice")
      val jsonString = gson.toJson(alice)
      println(jsonString) // Output: {"name":"Alice"}
        
      val tom = User("Tom",18)
      val jsonString2 = gson.toJson(tom)
      println(jsonString2) // Output: {"name":"Tom","age":18}

• 直接隱藏屬性

• import com.google.gson.Gson
  import com.google.gson.GsonBuilder
  import java.lang.reflect.Modifier
  import kotlinx.serialization.Transient
  
  // Ｇson 或是使用 @Transient 註解 + excludeFieldsWithModifiers 排除屬性
  // kotlinx.serialization 也可以用此註解，效果一樣
  data class User(
      val name: String,
      @Transient val age: Int = 30 // 被 transient 修飾符修飾
  ) {
      companion object {
          const val COMPANY = "ExampleCompany"  // 靜態屬性，將被排除
      }
  }
  
  fun main() {
      val gson: Gson = GsonBuilder()
          .excludeFieldsWithModifiers(Modifier.TRANSIENT, Modifier.STATIC) // 排除 transient 和 static 修飾符的屬性
          .create()
  
      val user = User(name = "Alice")
      val jsonString = gson.toJson(user)
  
      println(jsonString) // {"name":"Alice"}
        
      // kotlinx.serialization 也可以用此註解，效果一樣
      println(Json.encodeToString(user)) // Output: {"name":"Alice"}
  }
  

• 用途：控制 JSON 中輸出的詳細程度。

6. explicitNulls

• 說明：如果設置為 false，序列化時將省略值為 null 的屬性；如果設置為 true，則會顯示 null 值。
  預設(false)不輸出null 
• 範例：

  val json = Json { explicitNulls = true }
  val data = json.encodeToString(User("Alice", null))
    
  //   {
  //      "name": "Alice",
  //      "age": 25,
  //      "nickName": null
  //   }
  

• data class User2(
  //   @JsonNames("username", "user_name", "uname")
     val name: String,
     val age: Int? = null,
     val nickName: String? = null
  )
  
  val gsonIncludeNulls = GsonBuilder().serializeNulls().create() // 包含 null
  val gsonExcludeNulls = GsonBuilder().create() // 排除 null
  
  println(gsonIncludeNulls.toJson(User("Alice", 12, null))) 
    // {"name":"Alice","age":12,"nickName":null}
    
  println(gsonExcludeNulls.toJson(User("Alice", 13, null))) 
    // {"name":"Alice","age":13}
  

• 用途：控制如何處理 null 值，特別是在需要減少 JSON 大小時。

7. allowStructuredMapKeys

• 說明：如果設置為 true，允許使用複雜類型（例如，資料類）作為 Map 的鍵；否則僅允許基本類型作為鍵。
• 範例：

  val json = Json { allowStructuredMapKeys = true }
  val data = json.encodeToString(mapOf(User("Alice", 25) to "Developer"))
  
  /*
  [
      {
          "name": "Alice",
          "age": 25
      },
      "Developer"
  ]
  */

• // Gson 不直接支持複雜類型作為 Map 的鍵。通常需要將 Map 鍵轉換為字串形式：
  data class User(val name: String, val age: Int)
  val gson = GsonBuilder().create()
  val map = mutableMapOf(gson.toJson(User("Alice", 25)) to "Developer")
  val jsonString = gson.toJson(map) 
    // {"{\"name\":\"Alice\",\"age\":25}":"Developer"}
  

• // 使用 enableComplexMapKeySerialization 會有以意料之外結果
     val gson = GsonBuilder()
        .enableComplexMapKeySerialization()
        .create()
  
     val map = mutableMapOf(User("Alice", 25) to "Developer")
     println(map) // {User(name=Alice, age=25)=Developer}
     println(gson.toJson(map)) // [[{"name":"Alice","age":25},"Developer"]]
  /*    
  
  當你使用 enableComplexMapKeySerialization() 時，
  Gson 允許序列化包含複雜對象（例如，自定義的 User 類型）作為鍵的 Map。默認情況下，Gson 只能處理字符串等基本類型作為鍵。
  Gson 序列化 Map 時，會將鍵和值分別序列化。當使用複雜對象作為鍵時，Gson 會將這些鍵作為 JSON 的單獨條目來處理。
  
  由於 User("Alice", 25) 是一個非基本類型對象，Gson 將其序列化為 {"name":"Alice","age":25}，
  而 Map 的結果被序列化為包含鍵值對的數組。
  
  當你打印 gson.toJson(map) 時，結果是 [[{"name":"Alice","age":25},"Developer"]]，
  這意味著 JSON 的輸出是一個數組，數組中包含了鍵和值的另一個數組。
  這是因為 Gson 使用 List（一種數組結構）來表示 Map 的鍵值對，特別是在鍵是非基本類型的情況下。
  
  */
       
     val map = mutableMapOf(User("Alice", 25) to "Developer",User("John", 18) to "Student")
     println(map)
       // {User(name=Alice, age=25)=Developer, User(name=John, age=18)=Student}
     println(gson.toJson(map))
       // [[{"name":"Alice","age":25},"Developer"],[{"name":"John","age":18},"Student"]]

• 用途：用於需要使用複雜鍵的 JSON 結構。

8. allowSpecialFloatingPointValues

• 說明：如果設置為 true，允許特殊的浮點數值（例如，NaN、Infinity）在 JSON 中表示；如果為 false，則會拋出錯誤。
• 範例：

  val json = Json { allowSpecialFloatingPointValues = true }
  val data = json.encodeToString(Double.POSITIVE_INFINITY)
  
  // Infinity

• val gson = GsonBuilder()
      .registerTypeAdapter(Double::class.java, JsonSerializer<Double> { src, _, _ ->
          when {
              src.isNaN() || src.isInfinite() -> JsonPrimitive(src.toString())
              else -> JsonPrimitive(src)
          }
      })
      .registerTypeAdapter(Double::class.java, JsonDeserializer { json, _, _ ->
          when (val value = json.asString) {
              "NaN" -> Double.NaN
              "Infinity" -> Double.POSITIVE_INFINITY
              "-Infinity" -> Double.NEGATIVE_INFINITY
              else -> value.toDouble()
          }
      })
      .create()
  

• 用途：用於需要表示特殊浮點值的 JSON 序列化和反序列化。

如何混合使用這些配置

你可以將這些配置項混合使用來滿足特定的序列化和反序列化需求。

例如，假設你有一個情況需要反序列化非標準的 JSON 資料，並且需要忽略未知的鍵且保留結構化的 Map 鍵：

val json = Json {
    prettyPrint = true
    isLenient = true
    ignoreUnknownKeys = true
    encodeDefaults = false
    explicitNulls = false
    coerceInputValues = true
    allowStructuredMapKeys = true
    allowSpecialFloatingPointValues = true
}

val data = json.decodeFromString<User>("""{"name":"Alice", "unknownField":"value"}""")
println(data)
// User(name=Alice, age=30)

val gson = GsonBuilder()
    .setPrettyPrinting()
    .setLenient()
    .serializeNulls()  // Include nulls
    .registerTypeAdapter(User::class.java, JsonDeserializer { json, _, _ ->
        val jsonObject = json.asJsonObject
        val name = if (jsonObject.has("name")) jsonObject["name"].asString else "DefaultName"
        val age = if (jsonObject.has("age")) jsonObject["age"].asInt else 30 // Default value
        User(name, age)
    })
    .create()

val jsonString = """{"name":"Alice","unknownField":"value"}"""
val user: User = gson.fromJson(jsonString, User::class.java)
println(user) //User(name=Alice, age=30)
println(gson.toJson(User("Alice")))
  /*
  {
    "name": "Alice",
    "age": 30
  }
  */

在這個例子中，我們結合了多種配置來實現靈活且容錯的 JSON 解析和輸出，確保代碼能夠應對多種 JSON 格式和數據問題。這樣的設置可以讓你的應用更加健壯和靈活。

json default value:

/**
 * Configuration of the current [Json] instance available through [Json.configuration]
 * and configured with [JsonBuilder] constructor.
 *
 * Can be used for debug purposes and for custom Json-specific serializers
 * via [JsonEncoder] and [JsonDecoder].
 *
 * Standalone configuration object is meaningless and can nor be used outside the
 * [Json], neither new [Json] instance can be created from it.
 *
 * Detailed description of each property is available in [JsonBuilder] class.
 */
public class JsonConfiguration @OptIn(ExperimentalSerializationApi::class) internal constructor(
    public val encodeDefaults: Boolean = false,
    public val ignoreUnknownKeys: Boolean = false,
    public val isLenient: Boolean = false,
    public val allowStructuredMapKeys: Boolean = false,
    public val prettyPrint: Boolean = false,
    public val explicitNulls: Boolean = true,
    @ExperimentalSerializationApi
    public val prettyPrintIndent: String = "    ",
    public val coerceInputValues: Boolean = false,
    public val useArrayPolymorphism: Boolean = false,
    public val classDiscriminator: String = "type",
    public val allowSpecialFloatingPointValues: Boolean = false,
    public val useAlternativeNames: Boolean = true,
    @ExperimentalSerializationApi
    public val namingStrategy: JsonNamingStrategy? = null,
    @ExperimentalSerializationApi
    public val decodeEnumsCaseInsensitive: Boolean = false,
    @ExperimentalSerializationApi
    public val allowTrailingComma: Boolean = false,
    @ExperimentalSerializationApi
    public val allowComments: Boolean = false,
    @ExperimentalSerializationApi
    @set:Deprecated(
        "JsonConfiguration is not meant to be mutable, and will be made read-only in a future release. " +
            "The `Json(from = ...) {}` copy builder should be used instead.",
        level = DeprecationLevel.ERROR
    )
    public var classDiscriminatorMode: ClassDiscriminatorMode = ClassDiscriminatorMode.POLYMORPHIC,
) {

    /** @suppress Dokka **/
    @OptIn(ExperimentalSerializationApi::class)
    override fun toString(): String {
        return "JsonConfiguration(encodeDefaults=$encodeDefaults, ignoreUnknownKeys=$ignoreUnknownKeys, isLenient=$isLenient, " +
                "allowStructuredMapKeys=$allowStructuredMapKeys, prettyPrint=$prettyPrint, explicitNulls=$explicitNulls, " +
                "prettyPrintIndent='$prettyPrintIndent', coerceInputValues=$coerceInputValues, useArrayPolymorphism=$useArrayPolymorphism, " +
                "classDiscriminator='$classDiscriminator', allowSpecialFloatingPointValues=$allowSpecialFloatingPointValues, " +
                "useAlternativeNames=$useAlternativeNames, namingStrategy=$namingStrategy, decodeEnumsCaseInsensitive=$decodeEnumsCaseInsensitive, " +
                "allowTrailingComma=$allowTrailingComma, allowComments=$allowComments, classDiscriminatorMode=$classDiscriminatorMode)"
    }
}

5. 擴展性和客製化

在 JSON 序列化和反序列化過程中，kotlinx.serialization 和 Gson 都提供了強大的擴展性和客製化能力。這些能力允許開發者根據需要定義自定義的序列化和反序列化邏輯，以處理特殊格式的數據或滿足特定需求。

kotlinx.serialization 的擴展性和客製化

kotlinx.serialization 提供了一個簡潔的方式來自定義序列化和反序列化邏輯，通過實作 KSerializer 介面，你可以完全控制對象的序列化和反序列化過程。

如何實作自定義序列化器

1. 定義資料類：

   @Serializable
   data class Event(val name: String,
                    @Serializable(with = DateSerializer::class) val date: Date)
   
   

   在這個例子中，Event 類的 date 屬性使用了自定義序列化器 DateSerializer 來處理 Date 類型。

2. 實作 KSerializer 介面：

   object DateSerializer : KSerializer<Date> {
       override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("Date", PrimitiveKind.STRING)
   
       override fun serialize(encoder: Encoder, value: Date) {
           // 自定義的序列化邏輯，將 Date 轉換為 String
           val dateFormat = SimpleDateFormat("yyyy-MM-dd")
           val dateString = dateFormat.format(value)
           encoder.encodeString(dateString)
       }
   
       override fun deserialize(decoder: Decoder): Date {
           // 自定義的反序列化邏輯，將 String 轉換為 Date
           val dateFormat = SimpleDateFormat("yyyy-MM-dd")
           val dateString = decoder.decodeString()
           return dateFormat.parse(dateString)
       }
   }
   

   在這個例子中：

   • serialize 方法將 Date 對象序列化為 String 格式。
   • deserialize 方法將 String 反序列化為 Date 對象。

3. 使用自定義序列化器：

   val json = Json { }
   val event = Event("Conference", Date())
   val jsonString = json.encodeToString(event)
   println(jsonString) // {"name":"Conference","date":"2024-08-29"}
   
   val deserializedEvent = json.decodeFromString<Event>(jsonString)
   println(deserializedEvent)
   // Event(name=Conference, date=Thu Aug 29 00:00:00 CST 2024)

   自定義序列化器 DateSerializer 會自動在 encodeToString 和 decodeFromString 操作中被使用，處理 Event 類中的 date 屬性。

Gson 的擴展性和客製化

在 Gson 中，客製化序列化和反序列化是通過實作 JsonSerializer 和 JsonDeserializer 介面來實現的。這提供了類似的靈活性，可以完全控制對象的序列化和反序列化過程。

如何實作自定義序列化器和反序列化器

1. 定義資料類：

   data class Event(val name: String, val date: Date)
   

   與 kotlinx.serialization 不同，Gson 並不需要在資料類上添加任何特別的註解。

2. 實作 JsonSerializer 和 JsonDeserializer 介面：

   val dateSerializer = JsonSerializer<Date> { src, _, _ ->
       // 自定義的序列化邏輯，將 Date 轉換為 String
       val dateFormat = SimpleDateFormat("yyyy-MM-dd")
       JsonPrimitive(dateFormat.format(src))
   }
   
   val dateDeserializer = JsonDeserializer<Date> { json, _, _ ->
       // 自定義的反序列化邏輯，將 String 轉換為 Date
       val dateFormat = SimpleDateFormat("yyyy-MM-dd")
       dateFormat.parse(json.asString)
   }
   

   在這個例子中：

   • dateSerializer 是一個 JsonSerializer<Date>，負責將 Date 序列化為 JSON 字符串。
   • dateDeserializer 是一個 JsonDeserializer<Date>，負責將 JSON 字符串反序列化為 Date 對象。

3. 使用自定義序列化器和反序列化器：

   val gson = GsonBuilder()
       .registerTypeAdapter(Date::class.java, dateSerializer)
       .registerTypeAdapter(Date::class.java, dateDeserializer)
       .create()
   
   val event = Event("Conference", Date())
   val jsonString = gson.toJson(event)
   println(jsonString)
     // {"name":"Conference","date":"2024-08-29"}
   
   val deserializedEvent = gson.fromJson(jsonString, Event::class.java)
   println(deserializedEvent)
    // Event(name=Conference, date=Thu Aug 29 00:00:00 CST 2024)

   在這個例子中，registerTypeAdapter 方法用來註冊自定義的序列化器和反序列化器。Gson 會在序列化和反序列化 Date 類型時使用這些自定義的邏輯。

總結

• kotlinx.serialization 的擴展性和客製化：使用 KSerializer 介面來定義自定義的序列化和反序列化邏輯。這種方法能夠充分利用 Kotlin 的語言特性，如型別安全和編譯期檢查，確保序列化和反序列化過程中不會發生類型錯誤。

• Gson 的擴展性和客製化：使用 JsonSerializer 和 JsonDeserializer 介面來實現自定義的序列化和反序列化邏輯。Gson 的這種設計讓開發者可以非常靈活地處理各種數據格式和需求，特別是在 Java 環境中使用時。

這兩者都提供了足夠的靈活性來滿足大多數序列化和反序列化需求，不過 kotlinx.serialization 更加貼合 Kotlin 語言的特性和風格，而 Gson 則更加通用且適用於 Java 開發環境。

6. 依賴管理與體積

• 範例程式碼：

  // kotlinx.serialization
  implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0"
  
  // Gson
  implementation 'com.google.code.gson:gson:2.9.0'
  

• kotlinx.serialization

  • 依賴體積：kotlinx.serialization 是 Kotlin 官方提供的庫，專為 Kotlin 設計。這意味著它在體積上相對輕量，因為它不需要額外的依賴來運行 Kotlin 特性。它也不需要引入 Java 標準庫以外的額外依賴。

  • 依賴管理：kotlinx.serialization 的版本更新和依賴管理與 Kotlin 生態系統的版本緊密相關。它由 JetBrains 官方維護，更新相對頻繁，且通常會與 Kotlin 編譯器的更新一起釋出，這意味著使用者需要隨時注意 Kotlin 版本的變化。

  • 優勢：

    • 與 Kotlin 無縫集成：kotlinx.serialization 是一個 Kotlin 原生庫，它與 Kotlin 語言特性（如 data class、sealed class）無縫集成。
    • 輕量且效能優化：由於其緊密結合的 Kotlin 庫體積較小，並且效能優化專門針對 Kotlin 特性，這使得它在 Kotlin 開發中非常高效。
    • 易於在多平台項目中使用：kotlinx.serialization 支持 Kotlin Multiplatform，因此它可以在同一套代碼中使用於 Android、iOS 和其他平台。

  • 劣勢：

    • 僅適用於 Kotlin 項目：由於其與 Kotlin 的深度集成，如果你的項目是基於 Java 的，將不適合使用 kotlinx.serialization。

  Gson

  • 依賴體積：Gson 是一個通用的 Java 庫，設計用來支持各種 Java 對象的序列化和反序列化。由於它的廣泛兼容性和全面功能，Gson 的依賴體積相對較大，包含許多標準庫來處理各種情境。

  • 依賴管理：Gson 是由 Google 開發和維護的開源項目，但它的更新頻率比 kotlinx.serialization 要低。Gson 的版本變更通常是為了修復錯誤或增強功能，而不是頻繁的版本更新。

  • 優勢：

    • 廣泛的兼容性：作為一個 Java 庫，Gson 可以在任何 Java 環境中使用，包括 Kotlin 開發中。它可以處理 Java 的各種類型和情況，如泛型、嵌套類型等。
    • 功能全面且穩定：Gson 在處理複雜 JSON 結構時非常靈活，並且提供了豐富的自定義擴展選項（如自定義序列化和反序列化）。
    • 廣泛的社群支持：由於它的廣泛使用和成熟度，Gson 擁有大量的使用者和豐富的社群資源，許多常見問題和挑戰都有現成的解決方案。

  • 劣勢：

    • 較大的依賴體積：相比 kotlinx.serialization，Gson 的依賴更大，這可能會對應用的 APK 體積有影響，特別是在 Android 開發中。
    • 較少的 Kotlin 特性支持：雖然 Gson 可以用於 Kotlin 項目，但它並沒有 kotlinx.serialization 對 Kotlin 特性的原生支持，如 sealed class 和 data class。

7. 社群與支援

• 簡短說明： kotlinx.serialization 有官方支持且定期更新，更適合與 Kotlin 生態系統一起使用；Gson 有更長的歷史和廣泛的使用者社群，但更新頻率較低。

8. 總結與建議

• 簡短說明： 根據項目的需要選擇適合的工具。對於需要與 Kotlin 深度集成的應用，建議使用 kotlinx.serialization；如果需要支持更廣泛的 Java 類型或已有 Gson 的基礎設施，可以選擇 Gson。