如何检查Kotlin中获取的对象实例的内部组成结构与属性？

当我获取到一个对象时，我想了解如何检查该值由哪些组件构成。

inputData?.let {
   val detail: MutableState<Any?> = mutableStateOf(null)
   detail.value = inputData
}

我需要读取inputData的构成组件，确认该输入数据的内部结构是如何定义的。

补充代码上下文 #

class SelectDetail (
    private val purchaseDao: PurchaseDao,
    private val purchaseEntityMapper: PurchaseEntityMapper
) {
    fun execute(
        type: String,
        id: Int
    ): Flow<DataState<Any>> = flow {
        try {
            emit(DataState.loading())
            when(type) {
                "purchase" -> {
                    val cacheResult = purchaseDao.getPurchaseById(id)
                    val data = purchaseEntityMapper.fromEntity(cacheResult)
                    emit(DataState.success(data))
                }
            }
        }catch (e: Exception) {
            emit(DataState.error<Any>(e.message?: "Unknown Error"))
            e.printStackTrace()
        }
    }
}

之后在viewModel中调用该方法：

private fun selectDetail() {
    selectDetail.execute(type = type.value, id = detailId.value).onEach { dataState ->
        loading.value = dataState.loading

        dataState.data?.let { inputData ->
            // 此处需要实现逻辑
        }

        dataState.error?.let { error ->
            Log.d(TAG, "message: $error")
        }
    }.launchIn(viewModelScope)
}

DataState的定义如下：

data class DataState<out T>(
    val data: T? = null,
    val error: String? = null,
    val loading: Boolean = false,
) {
    companion object {

        fun <T> success(
            data: T
        ): DataState<T> {
            return DataState(
                data = data
            )
        }

        fun <T> error(
            message: String
        ): DataState<T> {
            return DataState(
                error = message
            )
        }

        fun <T> loading(): DataState<T> = DataState(loading = true)
    }
}

解决方案 #

你返回的DataState泛型固定为Any类型，运行时才能确定具体对象类型，有两种常用方案可以获取内部结构：

方案1：安全类型转换（生产环境推荐，性能最优） #

根据请求的type参数判断返回的对象类型，强转后直接读取属性即可：

dataState.data?.let { inputData ->
    when(type.value) {
        "purchase" -> {
            // 替换为PurchaseEntityMapper.fromEntity返回的实际实体类名
            val purchaseData = inputData as Purchase
            // 直接访问实体类所有属性
            val amount = purchaseData.amount
            val createTime = purchaseData.createTime
            // 赋值给状态变量
            detail.value = purchaseData
        }
        // 后续新增其他业务类型直接扩展分支即可
    }
}

方案2：反射获取全量属性（调试场景适用） #

如果不知道返回对象的具体类型，可以用Kotlin反射打印对象的所有属性名和对应值：

1. 首先引入kotlin反射依赖（项目build.gradle文件中添加，版本和项目kotlin版本保持一致）

implementation "org.jetbrains.kotlin:kotlin-reflect:1.8.0"

2. 逻辑处添加调试代码

dataState.data?.let { inputData ->
    // 打印对象类名
    Log.d("ObjectStructure", "对象类型：${inputData::class.simpleName}")
    // 遍历所有成员属性
    inputData::class.memberProperties.forEach { prop ->
        try {
            Log.d("ObjectStructure", "属性名：${prop.name}，属性值：${prop.get(inputData)}")
        } catch (e: Exception) {
            Log.d("ObjectStructure", "属性名：${prop.name}，读取失败：${e.message}")
        }
    }
}

运行后在Logcat过滤ObjectStructure标签即可看到该对象的完整结构。

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