使用Kotlin泛型向MongoDB插入数据时遇类型参数问题求助

错误原因 #

报错Cannot use 'T' as reified type parameter. Use a class instead.的核心原因是Kotlin泛型类型擦除：
KMongo的getCollection<T>()方法如果没有借助reified泛型，运行时无法获取T的实际类型信息。你当前的getCollection方法虽然接收了Class<T>参数，但调用database.getCollection<T>()时并没有利用这个参数，而是依赖已被擦除的泛型T，导致KMongo无法确定集合对应的实体类型。

修复方案 #

方案1：直接利用传入的Class对象获取集合 #

修改getCollection方法，显式将Class参数传给KMongo的getCollection方法，让它能在运行时识别类型：

import com.mongodb.ConnectionString
import com.mongodb.MongoClientSettings
import kotlinx.coroutines.runBlocking
import org.litote.kmongo.reactivestreams.*
import org.litote.kmongo.coroutine.*
import java.io.Serializable
import java.util.concurrent.TimeUnit

class MongoManager<TDataClass: Serializable>(
    private val clazz: Class<TDataClass>
) {
    private val client: CoroutineClient = KMongo.createClient(
       MongoClientSettings.builder()
           .applyConnectionString(ConnectionString("mongodb://localhost:27017"))
           .applyToConnectionPoolSettings {
               // 修正：这里要用it操作当前Builder，原代码创建新Builder未生效
               it.maxConnectionIdleTime(60000, TimeUnit.MILLISECONDS)
                   .minSize(5).maxSize(40)
           }
           .build()).coroutine
    private val database = client.getDatabase("local")
    private val bbMembershipData: CoroutineCollection<TDataClass>

    init {
        bbMembershipData = getCollection(this.clazz)
    }

    private fun <T: Serializable> getCollection(
        clazz: Class<T>
    ): CoroutineCollection<T> {
        // 关键修改：传入clazz参数给KMongo的getCollection
        return database.getCollection(clazz)
    }

    fun write(data: TDataClass) {
        runBlocking {
            bbMembershipData.insertOne(data)
        }
    }

    fun writeMany(data: List<TDataClass>) {
        runBlocking {
            bbMembershipData.insertMany(data)
        }
    }
}

方案2：用reified泛型简化实例创建（推荐） #

通过伴生对象的inline+reified泛型工厂方法，避免手动传递Class参数，更符合Kotlin风格：

import com.mongodb.ConnectionString
import com.mongodb.MongoClientSettings
import kotlinx.coroutines.runBlocking
import org.litote.kmongo.reactivestreams.*
import org.litote.kmongo.coroutine.*
import java.io.Serializable
import java.util.concurrent.TimeUnit

class MongoManager<TDataClass: Serializable> private constructor(
    private val collection: CoroutineCollection<TDataClass>
) {
    companion object {
        inline fun <reified TDataClass: Serializable> create(): MongoManager<TDataClass> {
            val client: CoroutineClient = KMongo.createClient(
                MongoClientSettings.builder()
                    .applyConnectionString(ConnectionString("mongodb://localhost:27017"))
                    .applyToConnectionPoolSettings {
                        it.maxConnectionIdleTime(60000, TimeUnit.MILLISECONDS)
                            .minSize(5).maxSize(40)
                    }
                    .build()
            ).coroutine
            val database = client.getDatabase("local")
            // reified泛型让KMongo能获取实际类型
            val collection = database.getCollection<TDataClass>()
            return MongoManager(collection)
        }
    }

    fun write(data: TDataClass) {
        runBlocking {
            collection.insertOne(data)
        }
    }

    fun writeMany(data: List<TDataClass>) {
        runBlocking {
            collection.insertMany(data)
        }
    }
}

使用方式：

// 无需手动传Class，直接指定泛型即可
val manager = MongoManager.create<YourDataClass>()

额外注意点 #

原代码中applyToConnectionPoolSettings的写法存在bug：你创建了新的ConnectionPoolSettings.Builder但没有将其应用到全局配置中，必须用it操作当前Builder实例，否则连接池的配置不会生效。

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