如何在编译期强制两个类字段名一致（类型可不同）？

当然可以在编译期（或者构建阶段）实现这个约束，而且完全不需要运行期反射，也不用为每个字段写一堆繁琐的泛型！下面给你几个实用的方案，从简单到进阶，你可以根据自己的场景选择：

方案1：最简单的手动编译期检查（适合字段不多的场景） #

如果你的字段数量不算多，可以写一个专门的“检查函数”，利用Kotlin的编译期引用特性来确保字段名一致。比如：

// 这个函数不用实际调用（或者在单元测试里跑一下），纯粹用来做编译期检查
fun enforceFieldConsistency(full: Full, partial: Partial, config: Configuration) {
    // 手动引用每个字段，只要任何一个类缺对应字段，这里就会编译报错
    full.stringField
    partial.stringField
    config.stringField

    full.intField
    partial.intField
    config.intField

    full.floatField
    partial.floatField
    config.floatField
}

这个方法的优点是零依赖，完全靠Kotlin本身的语法特性实现，编译期直接拦截问题。缺点是每次添加新字段，都要手动更新这个函数——不过反过来想，这也能强制你同步更新三个类的字段，避免遗漏。

⚠️ 注意：别用解构！Kotlin的数据类解构是按字段声明顺序匹配的，不是按字段名。如果字段顺序变了但名称对，解构不会报错，反而会匹配错误，完全失去检查的意义。

方案2：Gradle构建期检查（适合字段较多，不想写注解处理器的场景） #

如果字段很多，手动维护检查函数太麻烦，可以用Gradle任务在构建阶段自动对比字段名，一旦不一致就直接失败构建，相当于在编译前把问题拦住。

在你的build.gradle.kts里添加这个任务：

tasks.register("checkFieldContract") {
    // 依赖编译任务，确保类文件已经生成
    dependsOn(tasks.compileKotlin)
    doLast {
        // 加载三个类的字节码
        val fullClass = Class.forName("com.yourpackage.Full")
        val partialClass = Class.forName("com.yourpackage.Partial")
        val configClass = Class.forName("com.yourpackage.Configuration")

        // 获取所有字段名的集合
        val fullFields = fullClass.declaredFields.map { it.name }.toSet()
        val partialFields = partialClass.declaredFields.map { it.name }.toSet()
        val configFields = configClass.declaredFields.map { it.name }.toSet()

        // 检查Partial是否和Full字段完全一致
        val missingInPartial = fullFields - partialFields
        if (missingInPartial.isNotEmpty()) {
            error("Partial类缺少Full类的字段：${missingInPartial.joinToString(", ")}")
        }
        val extraInPartial = partialFields - fullFields
        if (extraInPartial.isNotEmpty()) {
            error("Partial类有多余的字段：${extraInPartial.joinToString(", ")}")
        }

        // 检查Configuration是否和Full字段完全一致
        val missingInConfig = fullFields - configFields
        if (missingInConfig.isNotEmpty()) {
            error("Configuration类缺少Full类的字段：${missingInConfig.joinToString(", ")}")
        }
        val extraInConfig = configFields - fullFields
        if (extraInConfig.isNotEmpty()) {
            error("Configuration类有多余的字段：${extraInConfig.joinToString(", ")}")
        }
    }
}

// 让编译任务完成后自动执行检查任务
tasks.compileKotlin.finalizedBy(tasks.checkFieldContract)

这个方案的优点是一劳永逸，添加新字段后完全不用手动更新任何代码，Gradle会自动帮你检查。这里虽然用了反射，但只是在构建阶段运行，完全不会影响应用的运行期性能，完全符合你“避免运行期反射”的要求。

方案3：KSP注解处理器（最优雅的长期维护方案） #

如果你的项目是长期维护的，字段会不断增加，推荐用Kotlin的KSP（Kotlin Symbol Processing）写一个简单的注解处理器，实现编译期的自动检查，还能顺便生成Full转Partial的转换代码，一举两得。

步骤1：添加KSP依赖 #

首先在build.gradle.kts里添加KSP插件和依赖（版本要和你的Kotlin版本匹配）：

plugins {
    id("com.google.devtools.ksp") version "1.9.20-1.0.14"
}

dependencies {
    ksp("com.google.devtools.ksp:symbol-processing-api:1.9.20-1.0.14")
}

// 让IDEA识别KSP生成的代码
kotlin.sourceSets.main {
    kotlin.srcDir("build/generated/ksp/main/kotlin")
}

步骤2：定义注解 #

在你的主代码里定义一个注解，用来标记需要同步字段的类：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE) // 只在源码阶段保留，编译后自动丢弃
annotation class MirrorFieldsOf(val target: KClass<*>)

步骤3：编写KSP处理器 #

创建一个新的模块（或者在主模块里）编写KSP处理器代码：

import com.google.devtools.ksp.processing.SymbolProcessor
import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
import com.google.devtools.ksp.processing.SymbolProcessorProvider
import com.google.devtools.ksp.symbol.KSClassDeclaration
import com.google.devtools.ksp.symbol.KSNode
import com.google.devtools.ksp.getAnnotationsByType
import com.google.devtools.ksp.processing.DiagnosticReporterFactory
import com.google.devtools.ksp.processing.DiagnosticSeverity

class FieldMirrorProcessor : SymbolProcessor {
    override fun process(resolver: com.google.devtools.ksp.processing.Resolver): List<com.google.devtools.ksp.symbol.KSAnnotated> {
        // 找到所有标注了@MirrorFieldsOf的类
        val mirrorClasses = resolver.getSymbolsWithAnnotation(MirrorFieldsOf::class.qualifiedName!!)
            .filterIsInstance<KSClassDeclaration>()

        mirrorClasses.forEach { mirrorClass ->
            // 获取注解指定的目标类（比如Full）
            val targetClassAnnotation = mirrorClass.getAnnotationsByType(MirrorFieldsOf::class).firstOrNull()
                ?: error("Missing @MirrorFieldsOf annotation on ${mirrorClass.simpleName.asString()}")
            val targetClassName = targetClassAnnotation.target.simpleName.asString()
            
            // 解析目标类的所有字段名
            val targetClass = resolver.getClassDeclarationByName(resolver.getKSNameFromString(targetClassName))
                ?: error("Target class $targetClassName not found")
            val targetFields = targetClass.getAllProperties()
                .map { it.name.asString() }
                .toSet()
            
            // 解析当前类的所有字段名
            val mirrorFields = mirrorClass.getAllProperties()
                .map { it.name.asString() }
                .toSet()
            
            // 检查字段是否完全一致
            val missingFields = targetFields - mirrorFields
            if (missingFields.isNotEmpty()) {
                reportError(
                    "Class ${mirrorClass.simpleName} is missing fields from $targetClassName: ${missingFields.joinToString(", ")}",
                    mirrorClass
                )
            }
            
            val extraFields = mirrorFields - targetFields
            if (extraFields.isNotEmpty()) {
                reportError(
                    "Class ${mirrorClass.simpleName} has extra fields not present in $targetClassName: ${extraFields.joinToString(", ")}",
                    mirrorClass
                )
            }
        }

        return emptyList()
    }

    private fun reportError(message: String, element: KSNode) {
        DiagnosticReporterFactory.createReporter().run {
            report(
                DiagnosticSeverity.ERROR,
                element,
                message
            )
        }
    }
}

// 注册处理器，让KSP能找到它
class FieldMirrorProcessorProvider : SymbolProcessorProvider {
    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
        return FieldMirrorProcessor()
    }
}

步骤4：使用注解 #

现在给你的Partial和Configuration类加上注解，指定它们要同步的目标类是Full：

data class Full(
    val stringField: String,
    val intField: Int,
    val floatField: Float,
    // 以后加新字段直接在这里加，其他两个类会自动检查
)

@MirrorFieldsOf(Full::class)
data class Partial(
    val stringField: String?,
    val intField: Int?,
    val floatField: Float?
)

@MirrorFieldsOf(Full::class)
data class Configuration(
    val stringField: Boolean,
    val intField: Boolean,
    val floatField: Boolean
)

这样，只要Partial或Configuration的字段和Full不一致，编译期就会直接报错，而且完全不需要手动维护任何检查代码。更棒的是，你还可以扩展这个处理器，自动生成Full.toPartial(config: Configuration)的扩展函数，把转换逻辑也自动化，彻底避免手动写重复代码。

根据你的业务场景，我推荐方案2或方案3：如果不想额外写处理器，方案2的Gradle任务足够简单好用；如果项目需要长期维护，方案3的注解处理器是最优雅的选择，能帮你省很多后续的维护工作。

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