用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响应和数据模型之间分配。默认值告诉序列化库该字段是可选的，并替换了pre 1.3.30的@Optional方法。

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

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

使用Thing数据类解析空对象时所遇到的错误是；

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比{}更便于解析，但有时您只需要使用后端发送给您的内容。

我脑海中有两个解决方案。

1. 更简单，特定于您的情况，使用map：

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())
    }
}

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

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"