如何对实现密封接口的Kotlin枚举进行多态序列化？

针对你遇到的密封接口Validation的枚举实现无法正常多态序列化的问题，以下是两种符合你期望格式的自定义序列化方案，适配Kotlin 1.7.21和Kotlin Serialization 1.4.1环境。

方案一：输出标准多态结构（type+value） #

这种方案生成你期望的第二种JSON格式，结构清晰，扩展性更好。

1. 编写通用枚举多态序列化器 #

这个序列化器专门处理实现Validation接口的枚举，负责序列化/反序列化时添加类型标识：

import kotlinx.serialization.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*

class ValidationEnumSerializer<T : Enum<T> & Validation>(
    private val enumClass: KClass<T>
) : KSerializer<T> {
    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("Validation") {
        element<String>("type")
        element<String>("value")
    }

    override fun serialize(encoder: Encoder, value: T) {
        encoder.encodeStructure(descriptor) {
            // 写入枚举类名作为类型标识
            encodeStringElement(descriptor, 0, enumClass.simpleName!!)
            // 写入枚举常量名
            encodeStringElement(descriptor, 1, value.name)
        }
    }

    override fun deserialize(decoder: Decoder): T {
        return decoder.decodeStructure(descriptor) {
            var type: String? = null
            var enumName: String? = null
            
            while (decodeElementIndex(descriptor) != CompositeDecoder.DECODE_DONE) {
                when (val index = decodeElementIndex(descriptor)) {
                    0 -> type = decodeStringElement(descriptor, index)
                    1 -> enumName = decodeStringElement(descriptor, index)
                }
            }

            // 根据类型标识匹配对应的枚举类
            val targetEnum = when (type) {
                AccountValidation::class.simpleName -> AccountValidation::class
                PasswordValidation::class.simpleName -> PasswordValidation::class
                else -> throw SerializationException("无法识别的验证类型：$type")
            } as KClass<T>

            return@decodeStructure java.lang.Enum.valueOf(targetEnum.java, enumName!!)
        }
    }
}

2. 给每个枚举绑定序列化器 #

为每个枚举类创建专属的序列化器对象（避免泛型导致的编译器错误），并标注在枚举上：

import kotlinx.serialization.Serializable

@Serializable(with = AccountValidationSerializer::class)
enum class AccountValidation(override val result: Int) : Validation {
    UNKNOWN(10),
    BLOCKED(20),
    OK(30)
}

object AccountValidationSerializer : ValidationEnumSerializer<AccountValidation>(AccountValidation::class)

@Serializable(with = PasswordValidationSerializer::class)
enum class PasswordValidation(override val result: Int) : Validation {
    SHORT(10),
    WEAK(20),
    OK(30)
}

object PasswordValidationSerializer : ValidationEnumSerializer<PasswordValidation>(PasswordValidation::class)

3. 测试序列化/反序列化 #

配置Json序列化器并测试：

import kotlinx.serialization.json.Json
import kotlin.test.Test
import kotlin.test.assertEquals

@Test
fun `多态序列化与反序列化测试`() {
    val json = Json {
        ignoreUnknownKeys = true
        prettyPrint = true
    }

    // 测试单个Validation实例
    val accountValid: Validation = AccountValidation.BLOCKED
    val accountJson = json.encodeToString(accountValid)
    // 输出：
    // {
    //   "type": "AccountValidation",
    //   "value": "BLOCKED"
    // }
    val deserializedAccount = json.decodeFromString<Validation>(accountJson)
    assertEquals(accountValid, deserializedAccount)

    // 测试ValidationResult
    val passwordResult = ValidationResult("myUserName", PasswordValidation.WEAK)
    val resultJson = json.encodeToString(passwordResult)
    // 输出：
    // {
    //   "userName": "myUserName",
    //   "validation": {
    //     "type": "PasswordValidation",
    //     "value": "WEAK"
    //   }
    // }
    val deserializedResult = json.decodeFromString<ValidationResult>(resultJson)
    assertEquals(passwordResult, deserializedResult)
}

方案二：输出单键对象格式 #

如果你偏好第一种{"PasswordValidation": "WEAK"}的格式，可以使用以下序列化器：

import kotlinx.serialization.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*

class ValidationEnumAltSerializer<T : Enum<T> & Validation>(
    private val enumClass: KClass<T>
) : KSerializer<T> {
    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("ValidationAlt") {
        element<String>(enumClass.simpleName!!)
    }

    override fun serialize(encoder: Encoder, value: T) {
        encoder.encodeStructure(descriptor) {
            encodeStringElement(descriptor, 0, value.name)
        }
    }

    override fun deserialize(decoder: Decoder): T {
        return decoder.decodeStructure(descriptor) {
            var typeName: String? = null
            var enumName: String? = null
            
            // 解析唯一的键值对
            while (decodeElementIndex(descriptor) != CompositeDecoder.DECODE_DONE) {
                val index = decodeElementIndex(descriptor)
                typeName = descriptor.getElementName(index)
                enumName = decodeStringElement(descriptor, index)
            }

            val targetEnum = when (typeName) {
                AccountValidation::class.simpleName -> AccountValidation::class
                PasswordValidation::class.simpleName -> PasswordValidation::class
                else -> throw SerializationException("无法识别的验证类型：$typeName")
            } as KClass<T>

            return@decodeStructure java.lang.Enum.valueOf(targetEnum.java, enumName!!)
        }
    }
}

同样给每个枚举绑定对应的序列化器（替换之前的ValidationEnumSerializer），测试后即可生成你想要的单键对象格式。

关键注意事项 #

1. 避免泛型序列化器直接绑定枚举：你之前尝试的泛型BoxedSerializer会引发编译器错误，因为Kotlin Serialization处理枚举时无法正确解析泛型上下文，因此必须为每个枚举创建专属的序列化器对象。
2. 密封接口的多态支持：因为Validation是密封接口，Kotlin Serialization会在编译时自动识别所有实现类，无需手动配置classDiscriminator或注册子类。
3. 类型映射逻辑：如果后续新增更多Validation枚举实现，只需在序列化器的when分支中添加对应的类型映射即可。

内容的提问来源于stack exchange，提问作者Ulrich Schuster