多模块下如何实现公共密封接口并满足New Relic JSON序列化需求？

核心问题分析 #

密封接口的层级限制（必须同一模块）导致无法跨模块实现，同时需要支持Kotlinx Serialization序列化以生成New Relic兼容的JSON。解决方案的核心是绕过密封接口的限制，同时确保多态序列化能正确识别跨模块的子类。

方案一：普通接口 + 多态序列化（推荐） #

这是最简洁的方案，利用Kotlinx Serialization的多态特性实现跨模块子类的序列化。

步骤1：修改common模块的Metric为普通接口 #

去掉sealed修饰符，保留@Serializable和公共字段：

@Serializable
interface Metric {
    val eventType: MetricType
    val status: Int
}

// 确保MetricType枚举可序列化
@Serializable
enum class MetricType {
    FOO, BAR
}

步骤2：在common模块定义基础序列化模块 #

创建一个基础的SerializersModule，用于聚合各模块的子类序列化器：

// common模块
val baseMetricSerializers = SerializersModule {
    polymorphic(Metric::class) {
        // 初始为空，后续由各模块补充子类
    }
}

步骤3：在Foo模块注册子类序列化器 #

在Foo模块中，将Foo类注册到多态序列化体系：

// Foo模块
val fooMetricSerializers = SerializersModule {
    polymorphic(Metric::class) {
        subclass(Foo::class)
    }
}

// Foo类定义保持不变（已带@SerialName和@Serializable）
@Serializable
@SerialName("Foo")
data class Foo(
    val version: Int?,
    override val status: Int,
    override val eventType: MetricType = MetricType.FOO
) : Metric

步骤4：合并序列化模块并初始化JSON实例 #

在应用启动时，合并所有模块的序列化模块，创建全局可用的Json实例：

// 应用初始化代码（比如Application类或DI容器）
val combinedSerializers = SerializersModule {
    include(baseMetricSerializers)
    include(fooMetricSerializers)
    // 其他模块的序列化模块也需添加进来
}

val newRelicJson = Json {
    serializersModule = combinedSerializers
    ignoreUnknownKeys = true // 适配New Relic可能的额外字段
    encodeDefaults = true // 可选：序列化默认值（比如Foo的eventType默认值）
}

序列化使用示例 #

用上述newRelicJson实例序列化Metric对象，生成的JSON会包含类型标识（type字段，对应@SerialName的值），符合New Relic的事件格式要求：

val fooMetric = Foo(version = 1, status = 200)
val jsonString = newRelicJson.encodeToString(Metric.serializer(), fooMetric)
// 输出JSON示例：
// {"type":"Foo","version":1,"status":200,"eventType":"FOO"}

方案二：自定义序列化器 + 注册机制（灵活扩展） #

如果需要更精细的序列化控制，可以自定义序列化器，并通过注册机制管理跨模块的子类。

步骤1：common模块实现MetricRegistry #

创建一个注册中心，用于存储各子类的序列化器和构造逻辑：

// common模块
object MetricRegistry {
    private val typeSerializers = mutableMapOf<MetricType, KSerializer<out Metric>>()

    fun register(type: MetricType, serializer: KSerializer<out Metric>) {
        typeSerializers[type] = serializer
    }

    fun getSerializer(type: MetricType): KSerializer<out Metric> =
        typeSerializers[type] ?: error("No serializer registered for MetricType: $type")
}

步骤2：自定义Metric序列化器 #

实现KSerializer，利用Registry获取对应子类的序列化器：

// common模块
object MetricCustomSerializer : KSerializer<Metric> {
    override val descriptor: SerialDescriptor = 
        buildClassSerialDescriptor("Metric") {
            element("eventType", MetricType.serializer().descriptor)
            element("status", Int.serializer().descriptor)
        }

    override fun serialize(encoder: Encoder, value: Metric) {
        // 先序列化公共字段，再委托给子类序列化器
        val subclassSerializer = MetricRegistry.getSerializer(value.eventType)
        encoder.encodeSerializableValue(subclassSerializer, value)
    }

    override fun deserialize(decoder: Decoder): Metric {
        // 先读取eventType，再获取对应子类序列化器反序列化
        val jsonElement = decoder.decodeJsonElement()
        val eventType = jsonElement.jsonObject["eventType"]?.let {
            MetricType.serializer().decodeJson(it)
        } ?: error("Missing eventType field in JSON")
        
        val subclassSerializer = MetricRegistry.getSerializer(eventType)
        return subclassSerializer.decodeJson(jsonElement)
    }
}

步骤3：修改Metric接口使用自定义序列化器 #

// common模块
@Serializable(with = MetricCustomSerializer::class)
interface Metric {
    val eventType: MetricType
    val status: Int
}

步骤4：在Foo模块注册子类 #

在Foo模块初始化时，将Foo的序列化器注册到Registry：

// Foo模块
init {
    MetricRegistry.register(MetricType.FOO, Foo.serializer())
}

// Foo类定义不变
@Serializable
@SerialName("Foo")
data class Foo(
    val version: Int?,
    override val status: Int,
    override val eventType: MetricType = MetricType.FOO
) : Metric

使用方式 #

序列化时直接使用Metric.serializer()即可：

val fooMetric = Foo(version = 1, status = 200)
val jsonString = Json.encodeToString(Metric.serializer(), fooMetric)

注意事项 #

• 确保所有Metric子类都添加@SerialName注解，避免序列化时的类型冲突。
• New Relic要求事件JSON包含明确的类型标识，eventType字段或type字段（由@SerialName生成）需确保存在。
• 如果使用多态序列化，需在应用启动时完成所有子类的序列化模块合并，避免序列化失败。

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