反序列化 Kotlin 枚举，同时忽略未知值

Question

我有一个枚举，我想使用 kotlinx.serialization 从 JSON 反序列化它，同时忽略未知值。这是枚举

@Serializable
enum class OperatingMode {
    Off, On, Auto
}

我所说的忽略未知数的意思是，如果我在 JSON 对象中有一个或多个模式不在该枚举中，则应将它们视为不存在：

{"foo":"bar","mode":"Banana"}
// same as
{"foo":"bar"}

{"modes":["Off","On","Banana"]}
// same as
{"modes":["Off","On"]}

我通过编写自定义序列化器来实现这一点，但对于这样一个简单的任务来说，它似乎相当冗长

internal object OperatingModeSafeSerializer : KSerializer<OperatingMode?> {
    override val descriptor = PrimitiveSerialDescriptor("OperatingMode", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: OperatingMode?) {
        // safe because @Serializable skips null fields
        encoder.encodeString(value!!.name)
    }

    override fun deserialize(decoder: Decoder): OperatingMode? {
        val string = decoder.decodeString()
        return try {
            OperatingMode.valueOf(string)
        } catch (_: Exception) {
            null
        }
    }
}

internal object OperatingModeSafeListSerializer: KSerializer<List<OperatingMode>> {
    private val delegateSerializer = ListSerializer(OperatingModeSafeSerializer)
    override val descriptor = delegateSerializer.descriptor

    override fun deserialize(decoder: Decoder): List<OperatingMode> {
        return decoder.decodeSerializableValue(delegateSerializer).filterNotNull()
    }

    override fun serialize(encoder: Encoder, value: List<OperatingMode>) {
        encoder.encodeSerializableValue(delegateSerializer, value)
    }
}

然后在每个反序列化的对象中

OperatingMode

我可以添加

@Serializable(with = OperatingModeSafeSerializer::class) // or
@Serializable(with = OperatingModeSafeListSerializer::class)

忽略未知数。

问题

1. 这是一个巨大的代码量。我希望有更多的枚举，我需要完全相同的行为，而且我真的不想为每个枚举复制粘贴这一点。我不知道如何使这种方法通用，因为这些对象不能通用，并且

   @Serializable(with = ...)

   需要编译时常量。
2. 理想情况下，我希望将此行为封装在枚举本身中，以便任何反序列化

   OperatingMode

   的操作都将忽略未知数。

Answer 1

目前我认为唯一的方法是使用

coerceInputValues

选项，枚举字段的默认值为 null，如下例所示：

@Serializable
enum class OperatingMode {
    Off, On, Auto
}

@Serializable
data class Foo(val name: String, val mode: OperatingMode? = null)

private val jsonFormat = Json {coerceInputValues = true}

fun main() {
    val jsonString = """{"name":"ignored","mode":"AnotherOption"}"""
    val foo = jsonFormat.decodeFromString<Foo>(jsonString)
    println(foo)
}

Answer 2

我找到了一种方法来重构我的问题中的方法，以避免大部分代码重复。

open class SafeSerializer<T>(
    private val serializer: KSerializer<T>
): KSerializer<T?> {
    override val descriptor = serializer.descriptor

    // safe because @Serializable skips null fields
    override fun serialize(encoder: Encoder, value: T?) = encoder.encodeSerializableValue(serializer, value!!)

    override fun deserialize(decoder: Decoder): T? = try {
        decoder.decodeSerializableValue(serializer)
    } catch (_: Exception) {
        null
    }
}
    
open class NonNullListSerializer<T>(
    serializer: KSerializer<T?>
): KSerializer<List<T>> {
    private val delegateSerializer = ListSerializer(serializer)
    override val descriptor = delegateSerializer.descriptor

    override fun serialize(encoder: Encoder, value: List<T>) = encoder.encodeSerializableValue(delegateSerializer, value)

    override fun deserialize(decoder: Decoder): List<T> = decoder.decodeSerializableValue(delegateSerializer).filterNotNull()
}

然后对于每个要以这种方式反序列化的枚举，您只需声明

object OperatingModeSafeSerializer: SafeSerializer<OperatingMode>(OperatingMode.serializer())
object OperatingModeSafeListSerializer: NonNullListSerializer<OperatingMode>(OperatingModeSafeSerializer)

NB. 这可能只适用于枚举等基本类型。如果您尝试将

SafeSerializer

与复杂类型一起使用，解码器可能会在解析 JSON 数组或对象等结构的过程中抛出异常。捕获该错误将使解码器处于无效状态。一种选择是更改

deserialize

以首先解码通用 JSON 元素而不捕获错误，然后 在捕获时将其解码为 T

，但这是以序列化器与 JSON 紧密耦合为代价的。

如果 kotlinx.serialization 有较少的贪婪解析器，在抛出之前尝试完全消耗元素，那么这将不是问题。