kotlinx.serialization.cbor.CborDecodingException：预计开始于地图，但找到78

Question

我正在尝试将Kotlin的serialization package之一与以下自定义示例类一起使用。我将通过添加真实类的List（也需要序列化）来扩展与实际用例匹配的此类，但是现在问题仅在于反序列化。我设法使序列化工作了（在第二段代码中，既有要序列化的对象，也有结果String）和似乎反序列化过程需要以相同的方式完成（即，通过使用NullableSerializer的实例）（实际上，我现在还没有找到一种简单而正确的方法来对编码对象进行反序列化）。这是一个简单但很复杂的课程。

@Serializable(with = EhEH.Companion::class)
data class EhEH(
    val i: Int
    , val txt: String
    //, val list: Array<String> // next feature, also with complex data, not only "simple" Strings
) {

    @Serializer(forClass = EhEH::class)
    companion object : KSerializer<EhEH> {
        public var deserialEhEH: DeserializationStrategy<EhEH> = EhEH


        override val descriptor: SerialDescriptor =
            SerialDescriptor("EhEHSerializer", PrimitiveKind.STRING)

        override fun serialize(encoder: Encoder, obj: EhEH) =
            encoder.encodeString(obj::class.qualifiedName!!)

        override fun deserialize(decoder: Decoder): EhEH {
            val dec = decoder.beginStructure(descriptor)
            var txt: String? = null
            var x: Int? = null
            var i = -1
            var notFinished = true
            do {
                i = dec.decodeElementIndex(descriptor)
                when (i) {
                    CompositeDecoder.READ_DONE -> notFinished = false
                    0 -> x = dec.decodeStringElement(descriptor, i).toIntOrNull()
                    1 -> txt = dec.decodeStringElement(descriptor, i)
                    else -> throw SerializationException("Unknown index $i")
                }
            } while (notFinished)
            dec.endStructure(descriptor)
            return EhEH(
                x ?: throw MissingFieldException("x"),
                txt ?: throw MissingFieldException("txt")
            )
        }

    }

    override fun toString(): String {
        return "EhEH(i=$i, s='$txt')"
    }
}

手动测试功能（其值仅打印为：）

@InternalSerializationApi
    fun testCborString(): String {
        var e: EhEH = EhEH(
            7,
            "poreccio"
            //, listOf("just", "another", "vacuum", "test")
        )
        return Cbor.dumps(
            NullableSerializer(
                EhEH.Companion
            ), e
        ) + " <-> " + (
                {
                    (Cbor.load(
                        NullableSerializer(
                            EhEH.Companion
                        ),
                        Cbor.dump(
                            NullableSerializer(EhEH.Companion), e
                        )
                        //the dumped value should be "781d62632e7472797669756d2e6170692e726573706f6e7365732e45684548"
                    )
                            as EhEH).toString()
                } as () -> String)()
    }

[当我尝试运行它时，该异常位于Cbor.load调用中，并且是：

kotlinx.serialization.cbor.CborDecodingException: Expected start of map, but found 78

我是整个互联网中唯一有此问题的人吗？

Answer 1

我自己找到了一种方法，错误基本上是两个：

1. override val descriptor: SerialDescriptor变量被设置为识别String，但这显然不是所希望的，因为它是一个Class：

   // val stringArraySerializer= ArraySerializer(String.serializer())
   SerialDescriptor("EhEHSerializer", StructureKind.CLASS) {
           element<Int>("i")
           element<String>("txt")
           // element<Array<String>>("list") // kept here for future references for Array of primitive stuffs
           // element("arrComplexClass", AComplexClassTaggedSerializable.descriptor) // in case of Array of complex objects, a tag @Serializable and a companion object implementing Kserializable<AComplexClassTaggedSerializable> is needed
       }
   

2. 类似地，方法override fun serialize(encoder: Encoder, obj: EhEH)被实现为产生String（特别是持有类名的字符串）。所需的实现是：

   override fun serialize(encoder: Encoder, obj: EhEH){
       var ce = encoder.beginStructure(
           descriptor,
           Int.serializer(),
           String.serializer(),
           //stringArraySerializer, // kept here for future references for
           // serializerArray_AComplexClassTaggedSerializable
       )
       ce.encodeIntElement(descriptor, 0, obj.i)
       ce.encodeStringElement(descriptor, 1, obj.txt)
       /*ce.encodeSerializableElement(
           descriptor, 2,
           stringArraySerializer, obj.arrOfStrings
       )*/
       /*ce.encodeSerializableElement(
           descriptor, 3,
           serializerArray_AComplexClassTaggedSerializable,
           obj.arrComplexClass
       )*/
       ce.endStructure(descriptor)
   
   }
   

   此外，其他基本注释：

3. 需要将复杂的对象包装在NullableSerializer上，同样在其中Array的情况下：

   val serializerArray_AComplexClassTaggedSerializable =
       ArraySerializer<AComplexClassTaggedSerializable, AComplexClassTaggedSerializable?>(
           NullableSerializer(
               AComplexClassTaggedSerializable.Companion
           )
       ) // it's a variable used on the code above
   

4. 在序列化和反序列化（即：分别为Cbor.dump和Cbor.load）上，需要NullableSerializer作为第一个参数：

   var nse = NullableSerializer(AComplexClassTaggedSerializable)
   println( Cbor.dump(nse, someInstanceOfThatComplexClass ).toString())
   //and....
   var o = (Cbor.load(nse, "...here go something..") as EhEH
   // use "o"