有没有办法在不使用反射的情况下迭代数据类的所有字段？

Question

我知道使用javassist的反射的替代方法，但是使用javassist有点复杂。而且由于lambda或koltin中的某些其他功能，javassist有时不能很好地工作。因此，还有其他方法可以不使用反射来迭代数据类的所有字段。

Answer 1

有两种方法。第一个相对容易，基本上就是评论中提到的：假设您知道有多少个字段，您可以将其解包并将其放入列表中，然后迭代这些字段。或者直接使用它们：

data class Test(val x: String, val y: String) {
    fun getData() : List<Any> = listOf(x, y)
}

data class Test(val x: String, val y: String) 
...

val (x, y) = Test("x", "y")
// And optionally throw those in a list

虽然像这样迭代只是一个额外的步骤，但这至少是一种可以相对轻松地解压缩数据类的方法。

如果你不知道有多少个字段（或者你不想重构），你有两个选择：

第一种是使用反射。但正如你提到的，你不想要这个。

这就留下了第二个更复杂的预处理选项：注释。请注意，这仅适用于您控制的数据类- 除此之外，您会被库/框架编码器的反射或实现所困扰。

注释可用于多种用途。其中之一是元数据，也是代码生成。这是一个有点复杂的替代方案，需要一个额外的模块才能获得正确的编译顺序。如果它没有按正确的顺序编译，你最终会得到未处理的注释，这有点违背了目的。

我还创建了一个可以与 Gradle 一起使用的版本，但这在文章的末尾，它是您自己实现它的捷径。

请注意，我只使用纯 Kotlin 项目对此进行了测试- 我个人在 Java 和 Kotlin 之间的注释方面遇到过问题（尽管 Lombok 是这样），所以我不保证如果从 Java 调用这将在编译时工作。另请注意，这很复杂，但可以避免运行时反射。

解释

这里的主要问题是某种内存问题。这将在您每次调用该方法时创建一个新列表，这使得它与enums 使用的方法非常相似。

超过 10000 次迭代的本地测试也显示出执行我的方法大约 200 毫秒的一般一致性，而反射大约为 600 毫秒。然而，对于一次迭代，我的使用约 20 毫秒，而反射使用 400 到 500 毫秒。在一次运行中，反射花费了 1500 (!) 毫秒，而我的方法花费了 18 毫秒。

另请参阅Java 反射：为什么这么慢？. 这似乎也会影响 Kotlin。每次调用时创建新列表的内存影响可能会很明显，但它也会被收集，所以它应该不是那么大的问题。

作为参考，用于基准测试的代码（这将在文章的其余部分之后有意义）：

@AutoUnpack data class ExampleDataClass(val x: String, val y: Int, var m: Boolean)

fun main(a: Array<String>) {
    var mine = 0L
    var reflect = 0L
    // for(i in 0 until 10000) {
        var start = System.currentTimeMillis()
        val cls = ExampleDataClass("example", 42, false)
        for (field in cls) {
            println(field)
        }
        mine += System.currentTimeMillis() - start

        start = System.currentTimeMillis()
        for (prop in ExampleDataClass::class.memberProperties) {
            println("${prop.name} = ${prop.get(cls)}")
        }
        reflect += System.currentTimeMillis() - start
    // }
    println(mine)
    println(reflect)
}

从头开始设置

这基于两个模块：消费者模块和处理器模块。处理器必须在一个单独的模块中。它需要与消费者分开编译，注解才能正常工作。

首先，你的消费者项目需要注解处理器：

apply plugin: 'kotlin-kapt'

此外，您需要添加存根生成。它抱怨它在编译时未使用，但没有它，生成器似乎对我来说坏了：

kapt {
    generateStubs = true
}

现在一切就绪，为解包器创建一个新模块。如果您还没有，请添加 Kotlin 插件。在这个项目中你不需要注解处理器 Gradle 插件。这只是消费者需要的。但是，您确实需要kotlinpoet：

implementation "com.squareup:kotlinpoet:1.2.0"

这是为了简化代码生成本身的各个方面，这是这里的重要部分。

现在，创建注释：

@Retention(AnnotationRetention.SOURCE)
@Target(AnnotationTarget.CLASS)
annotation class AutoUnpack

这几乎就是你所需要的。保留设置为源是因为它在运行时没有价值，它只针对编译时。

接下来是处理器本身。这有点复杂，所以请耐心等待。作为参考，这使用javax.*包进行注释处理。Android 注意：假设您可以在compileOnly范围上插入 Java 模块而不受 Android SDK 限制，这可能会起作用。正如我之前提到的，这主要是针对纯 Kotlin 的；Android 可能会工作，但我还没有测试过。

无论如何，生成器：

因为我找不到一种方法在不触及其余部分的情况下将方法生成到类中（并且因为根据this，这是不可能的），所以我将采用扩展函数生成方法。

你需要一个class UnpackCodeGenerator : AbstractProcessor(). 在那里，您首先需要两行样板：

override fun getSupportedAnnotationTypes(): MutableSet<String> = mutableSetOf(AutoUnpack::class.java.name)
override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latest()

继续，有处理。覆盖进程函数：

override fun process(annotations: MutableSet<out TypeElement>, roundEnv: RoundEnvironment): Boolean {
    // Find elements with the annotation
    val annotatedElements = roundEnv.getElementsAnnotatedWith(AutoUnpack::class.java)
    if(annotatedElements.isEmpty()) {
        // Self-explanatory
        return false;
    }
    // Iterate the elements
    annotatedElements.forEach { element ->
        // Grab the name and package 
        val name = element.simpleName.toString()
        val pkg = processingEnv.elementUtils.getPackageOf(element).toString()
        // Then generate the class
        generateClass(name,
            if (pkg == "unnamed package") "" else pkg, // This is a patch for an issue where classes in the root 
                                                       // package return package as "unnamed package" rather than empty, 
                                                       // which breaks syntax because "package unnamed package" isn't legal. 
            element)
    }
    // Return true for success
    return true;
}

这只是建立了一些后来的框架。真正的魔法发生在generateClass函数中：

private fun generateClass(className: String, pkg: String, element: Element){
    val elements = element.enclosedElements
    val classVariables = elements
        .filter {
            val name = if (it.simpleName.contains("\$delegate"))
                it.simpleName.toString().substring(0, it.simpleName.indexOf("$"))
            else it.simpleName.toString()
            it.kind == ElementKind.FIELD // Find fields
                    && Modifier.STATIC !in it.modifiers // that aren't static (thanks to sebaslogen for issue #1: https://github.com/LunarWatcher/KClassUnpacker/issues/1)
                    // Additionally, we have to ignore private fields. Extension functions can't access these, and accessing
                    // them is a bad idea anyway. Kotlin lets you expose get without exposing set. If you, by default, don't
                    // allow access to the getter, there's a high chance exposing it is a bad idea.
                    && elements.any { getter -> getter.kind == ElementKind.METHOD // find methods
                            && getter.simpleName.toString() ==
                                    "get${name[0].toUpperCase().toString() + (if (name.length > 1) name.substring(1) else "")}" // that matches the getter name (by the standard convention)
                            && Modifier.PUBLIC in getter.modifiers // that are marked public
                    }
        } // Grab the variables
        .map {
            // Map the name now. Also supports later filtering
            if (it.simpleName.endsWith("\$delegate")) {
                // Support by lazy
                it.simpleName.subSequence(0, it.simpleName.indexOf("$"))
            } else it.simpleName
        }
    if (classVariables.isEmpty()) return; // Self-explanatory
    val file = FileSpec.builder(pkg, className)
        .addFunction(FunSpec.builder("iterator") // For automatic unpacking in a for loop
            .receiver(element.asType().asTypeName().copy()) // Add it as an extension function of the class
            .addStatement("return listOf(${classVariables.joinToString(", ")}).iterator()") // add the return statement. Create a list, push an iterator.
            .addModifiers(KModifier.PUBLIC, KModifier.OPERATOR) // This needs to be public. Because it's an iterator, the function also needs the `operator` keyword
            .build()
        ).build()
    // Grab the generate directory.
    val genDir = processingEnv.options["kapt.kotlin.generated"]!!
    // Then write the file.
    file.writeTo(File(genDir, "$pkg/${element.simpleName.replace("\\.kt".toRegex(), "")}Generated.kt"))
}

所有相关行都有解释使用的注释，以防您不熟悉它的作用。

最后，为了让处理器进行处理，您需要注册它。在对发电机的模块中，添加一个名为javax.annotation.processing.Processor下main/resources/META-INF/services。在那里你写：

data class Test(val x: String, val y: String) {
    fun getData() : List<Any> = listOf(x, y)
}

从这里，您需要使用compileOnly和链接它kapt。如果您将其作为模块添加到您的项目中，您可以执行以下操作：

kapt project(":ClassUnpacker")
compileOnly project(":ClassUnpacker")

替代源设置：

就像我之前提到的，为了方便起见，我将它捆绑在一个罐子里。它与 SO 使用的许可相同（CC-BY-SA 3.0），并且它包含与答案完全相同的代码（尽管编译为单个项目）。

如果你想使用这个，只需添加 Jitpack 仓库：

repositories {
    // Other repos here
    maven { url 'https://jitpack.io' }
}

并将其与：

kapt 'com.github.LunarWatcher:KClassUnpacker:v1.0.1'
compileOnly "com.github.LunarWatcher:KClassUnpacker:v1.0.1"

请注意，此处的版本可能不是最新的：此处提供了最新的版本列表。帖子中的代码仍然旨在反映 repo，但版本并不重要到每次都进行编辑。

用法

无论您最终使用哪种方式获取注释，使用方法都相对简单：

@AutoUnpack data class ExampleDataClass(val x: String, val y: Int, var m: Boolean)

fun main(a: Array<String>) {
    val cls = ExampleDataClass("example", 42, false)
    for(field in cls) {
        println(field)
    }
}

这打印：

data class Test(val x: String, val y: String) 
...

val (x, y) = Test("x", "y")
// And optionally throw those in a list

现在您有了一种无需反射的迭代字段的方法。

请注意，本地测试已部分使用 IntelliJ 完成，但 IntelliJ 似乎不喜欢我 - 我有各种失败的构建，其中 gradlew clean && gradlew build命令行奇怪地工作正常。我不确定这是本地问题，还是普遍问题，但是如果您从 IntelliJ 构建，您可能会遇到类似这样的问题。

此外，如果构建失败，您可能会收到错误消息。IntelliJ linter 构建在某些源的构建目录之上，因此如果构建失败并且未生成具有扩展功能的文件，则会导致它显示为错误。构建通常在我测试时解决这个问题（使用两个模块和来自 Jitpack）。

如果您使用Android Studio或IntelliJ ，您可能还必须启用注释处理器设置。