使用 kotlinx.serialization 解析空对象

Question

我很难理解如何使用实验性 kotlinx.serialization 库解析空对象 {}。当实际上 API 响应可以是其中之一时，就会出现并发症；

{
  "id": "ABC1",
  "status": "A_STATUS"
}

或

{}

我用作序列化程序的数据结构是；

data class Thing(val id: String = "", val status: String = "")

这用 @kotlinx.serialization.Serializable 注释并在 API 客户端库中用于在原始 API 响应和数据模型之间编组。默认值告诉序列化库该字段是可选的，并替换了 Kotlin 1.3.30 之前的 @Optional 方法。

最后，我使用的 kotlinx.serialization.json.Json 解析器通过使用 nonstrict 模板应用了配置。

如何定义一个可以解析空对象和预期数据类型的序列化程序kotlinx.serialization？我需要自己编写 KSerialiser 还是缺少配置。理想情况下，空对象应该是 ignored/parsed 作为 null?

使用 Thing 数据 class 解析空对象时出现的错误是；

Field 'id' is required, but it was missing

Answer 1

所以这归结为 kotlinCompilerClasspath 具有不同的 kotlin 版本（1.3.21，而不是 1.3.31）。

有趣的是，这是由于我在将 gradle 插件项目配置为 而不是 为 kotlin-dsl 插件指定版本时遵循的建议。

明确依赖我需要的版本修复了 kotlinx.serialisation 行为（主线代码没有变化）

Answer 2

是的，理想情况下 null 而不是 {} 更便于解析，但有时您只需要使用后端发送给您的内容

我想到了 2 个解决方案。

更简单，具体到您使用地图的情况：

import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test

class ThingMapSerializerTest {

    @Test
    fun `should deserialize to non empty map`() {
        val thingMap: Map<String, String> =
            Json.decodeFromString("""{"id":"ABC1","status":"A_STATUS"}""")

        assertTrue(thingMap.isNotEmpty())
        assertEquals("ABC1", thingMap["id"])
        assertEquals("A_STATUS", thingMap["status"])
    }

    @Test
    fun `should deserialize to empty map`() {
        val thingMap: Map<String, String> = Json.decodeFromString("{}")

        assertTrue(thingMap.isEmpty())
    }
}

更复杂但更通用，适用于任何值类型的组合。我建议使用显式空值密封 class 而不是使用空默认值的数据 class：

import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerializationException
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.descriptors.buildClassSerialDescriptor
import kotlinx.serialization.descriptors.serialDescriptor
import kotlinx.serialization.encoding.CompositeDecoder
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.encoding.decodeStructure
import kotlinx.serialization.json.Json
import org.junit.Assert.assertEquals
import org.junit.Test

class ThingSerializerTest {

    @Test
    fun `should deserialize to thing`() {
        val thing: OptionalThing =
            Json.decodeFromString(
                OptionalThing.ThingSerializer,
                """{"id":"ABC1","status":"A_STATUS"}"""
            )

        assertEquals(OptionalThing.Thing(id = "ABC1", status = "A_STATUS"), thing)
    }

    @Test
    fun `should deserialize to empty`() {
        val thing: OptionalThing =
            Json.decodeFromString(OptionalThing.ThingSerializer, "{}")

        assertEquals(OptionalThing.Empty, thing)
    }

    sealed class OptionalThing {
        data class Thing(val id: String = "", val status: String = "") : OptionalThing()
        object Empty : OptionalThing()

        object ThingSerializer : KSerializer<OptionalThing> {
            override val descriptor: SerialDescriptor =
                buildClassSerialDescriptor("your.app.package.OptionalThing") {
                    element("id", serialDescriptor<String>(), isOptional = true)
                    element("status", serialDescriptor<String>(), isOptional = true)
                }

            override fun deserialize(decoder: Decoder): OptionalThing {
                decoder.decodeStructure(descriptor) {
                    var id: String? = null
                    var status: String? = null
                    loop@ while (true) {
                        when (val index = decodeElementIndex(descriptor)) {
                            CompositeDecoder.DECODE_DONE -> break@loop
                            0 -> id = decodeStringElement(descriptor, index = 0)
                            1 -> status = decodeStringElement(descriptor, index = 1)
                            else -> throw SerializationException("Unexpected index $index")
                        }
                    }
                    return if (id != null && status != null) Thing(id, status)
                    else Empty
                }
            }

            override fun serialize(encoder: Encoder, value: OptionalThing) {
                TODO("Not implemented, not needed")
            }
        }
    }

}

当 'Thing' 是 json 对象中的字段时：

  "thing":{"id":"ABC1","status":"A_STATUS"} // could be {}

你可以这样注释属性:

@Serializable(with = OptionalThing.ThingSerializer::class)
val thing: OptionalThing

测试对象：

classpath "org.jetbrains.kotlin:kotlin-serialization:1.4.10"
implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.1"

使用 kotlinx.serialization 解析空对象

Parsing empty object with kotlinx.serialization

json

kotlin

kotlinx.serialization