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

Question

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

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

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

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

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

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)

注意，这可能只适用于枚举等基本类型。如果您尝试使用SafeSerializer复杂类型，解码器可能会在解析 JSON 数组或对象等结构的过程中引发异常。捕获该错误将使解码器处于无效状态。一种选择是更改deserialize为首先在不捕获错误的情况下解码通用 JSON 元素，然后在捕获时对其进行解码T，但这是以序列化器与 JSON 紧密耦合为代价的。

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