Kotlin中如何访问泛型参数的伴生对象？实体工厂场景求解

我定义了IEntity和IEntityFactory接口，以及Person类，同时还有多个类似Person、具备独有属性的IEntity实现类。要求Person类实现IEntity的属性，且其伴生对象实现IEntityFactory的「静态」方法，但接口无法强制约束这一点。

相关代码如下：

interface IEntityFactory<T : IEntity> {
    // 用于跨传输识别对象类型的字符串，如"entity.person"
    val objectType: String
    // 从Map获取类实例的方法
    fun fromMap(map: Map<String, @Contextual Any?>): T
    // 检查给定字符串是否符合当前对象类型的方法
    fun isOfType(objectType: String?): Boolean
}

interface IEntity {
    val objectType: String
    val name: String
}

@Serializable
data class Person(
    override val objectType: String,
    override val name: String,
) : IEntity {

    companion object : IEntityFactory<Person> {
        override val objectType: String = "entity.person"
        override fun fromMap(map: Map<String, Any?>) = // 具体实现
        override fun isOfType(objectType: String?) = // 具体实现
    }
}

我希望便捷地将Map<String, Any>转换为任意IEntity实现类，尝试编写了如下扩展函数：

fun <T : IEntity> Map<String, String>.toData(): T? {
    val objectType = this["objectType"]!!.lowercase()
    if(T.isOfType(objectType)) return T.fromMap(this)
}

显然这段代码无法运行：编译器无法知晓所有IEntity实现类的伴生对象都实现了IEntityFactory，也就无法调用IEntity.fromMap()等方法。由于接口无法强制约束伴生对象的实现，请问有没有符合Kotlin风格的解决方案？

补充尝试：参考方案编写了如下代码，但希望得到更贴合需求的优化：

inline fun <reified T : IEntity> Map<String, String>.toData(): T? {
    return try {
        val jsonMap = Json.encodeToString(this)
        Json.decodeFromString(jsonMap)
    } catch (_: Exception) {
        null
    }
}

方案一：具体化类型+伴生对象约束 #

借助Kotlin的**具体化类型（reified）**和伴生对象的类型约定，让编译器识别IEntity实现类的伴生对象与IEntityFactory的绑定关系：

1. 定义辅助接口，约定IEntity实现类的伴生对象必须实现IEntityFactory：

interface EntityWithFactory<T : IEntity> : IEntity {
    companion object : IEntityFactory<T>
}

2. 修改Person类实现该接口：

@Serializable
data class Person(
    override val objectType: String,
    override val name: String,
) : EntityWithFactory<Person> {

    companion object : IEntityFactory<Person> {
        override val objectType: String = "entity.person"
        
        override fun fromMap(map: Map<String, Any?>): Person {
            return Person(
                objectType = map["objectType"] as String,
                name = map["name"] as String
            )
        }
        
        override fun isOfType(objectType: String?): Boolean {
            return objectType?.lowercase() == this.objectType.lowercase()
        }
    }
}

3. 编写扩展函数，通过具体化类型获取伴生对象并完成转换：

inline fun <reified T : EntityWithFactory<T>> Map<String, Any?>.toData(): T? {
    val objectType = this["objectType"]?.toString()?.lowercase() ?: return null
    val factory = T::class.companionObjectInstance as? IEntityFactory<T> ?: return null
    return if (factory.isOfType(objectType)) factory.fromMap(this) else null
}

调用示例：

val personMap = mapOf("objectType" to "entity.person", "name" to "Alice")
val person = personMap.toData<Person>()

方案二：全局工厂注册表 #

创建全局注册表管理所有IEntityFactory实例，通过objectType匹配对应的工厂：

1. 定义注册表对象：

object EntityFactoryRegistry {
    private val factories = mutableMapOf<String, IEntityFactory<out IEntity>>()

    fun register(factory: IEntityFactory<out IEntity>) {
        factories[factory.objectType.lowercase()] = factory
    }

    fun getFactory(objectType: String): IEntityFactory<out IEntity>? {
        return factories[objectType.lowercase()]
    }
}

2. 在Person伴生对象中注册工厂：

@Serializable
data class Person(
    override val objectType: String,
    override val name: String,
) : IEntity {

    companion object : IEntityFactory<Person> {
        override val objectType: String = "entity.person"

        init {
            EntityFactoryRegistry.register(this)
        }

        override fun fromMap(map: Map<String, Any?>): Person {
            return Person(
                objectType = map["objectType"] as String,
                name = map["name"] as String
            )
        }

        override fun isOfType(objectType: String?): Boolean {
            return objectType?.lowercase() == this.objectType.lowercase()
        }
    }
}

3. 编写通用转换函数：

fun Map<String, Any?>.toEntity(): IEntity? {
    val objectType = this["objectType"]?.toString()?.lowercase() ?: return null
    val factory = EntityFactoryRegistry.getFactory(objectType) ?: return null
    return factory.fromMap(this)
}

// 转为具体类型的封装
inline fun <reified T : IEntity> Map<String, Any?>.toSpecificEntity(): T? {
    return toEntity() as? T
}

调用示例：

val personMap = mapOf("objectType" to "entity.person", "name" to "Bob")
val person = personMap.toSpecificEntity<Person>()

方案三：优化序列化方案（基于你的补充尝试） #

如果使用Kotlinx Serialization，可优化代码避免冗余的JSON字符串转换，直接利用Map的序列化支持：

import kotlinx.serialization.json.Json
import kotlinx.serialization.json.encodeToJsonElement
import kotlinx.serialization.json.decodeFromJsonElement

inline fun <reified T : IEntity> Map<String, String>.toData(): T? {
    return try {
        val jsonElement = Json.encodeToJsonElement(this)
        Json.decodeFromJsonElement(jsonElement)
    } catch (_: Exception) {
        null
    }
}

这种方式依赖序列化框架自动处理字段映射，无需手动编写fromMap逻辑，适合大多数场景。

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