如何仅通过函数名字符串，用反射调用Kotlin无类顶层函数？

类成员函数的反射调用 #

如果函数是类的成员，反射调用很直接：

定义类和函数：

package com.example

class MyClass {
    fun myFunction(): String {
        return "result"
    }
}

反射调用代码：

val myClass = Class.forName("com.example.MyClass").kotlin
val myFunction = myClass.functions.firstOrNull { it.name == "myFunction" }
val result = myFunction?.call()

顶层函数的反射困境 #

但如果是无类的顶层函数，比如：

package com.example

fun myFunction(): String {
    return "result"
}

在JVM上，顶层函数会被编译到文件名+Kt后缀的类中，但如果不知道该函数所在的文件名，常规反射方式无法直接定位到对应类。

解决方案：遍历包下类查找目标函数 #

既然知道顶层函数的包名（com.example）和函数名，我们可以通过遍历该包下的所有类，逐个检查是否包含目标函数，找到后再调用：

实现代码 #

import kotlin.reflect.full.functions
import java.net.URLClassLoader
import java.util.jar.JarFile

fun findAndCallTopLevelFunction(targetPackage: String, functionName: String): Any? {
    val classLoader = Thread.currentThread().contextClassLoader as URLClassLoader
    val packagePath = targetPackage.replace('.', '/')

    classLoader.urLs.forEach { url ->
        when (url.protocol) {
            "file" -> handleDirectoryClasses(url.toURI().path, targetPackage, packagePath, functionName)?.let { return it }
            "jar" -> handleJarClasses(url.path, targetPackage, packagePath, functionName)?.let { return it }
        }
    }
    return null
}

private fun handleDirectoryClasses(dirPath: String, targetPackage: String, packagePath: String, functionName: String): Any? {
    val packageDir = java.io.File(dirPath, packagePath)
    if (!packageDir.exists() || !packageDir.isDirectory) return null

    packageDir.listFiles { file -> file.name.endsWith(".class") }?.forEach { classFile ->
        val className = targetPackage + "." + classFile.name.substringBeforeLast(".class")
        try {
            val kClass = Class.forName(className).kotlin
            kClass.functions.firstOrNull {
                it.name == functionName && it.parameters.isEmpty()
            }?.let { return it.call() }
        } catch (_: Exception) {
            // 跳过加载失败的类
        }
    }
    return null
}

private fun handleJarClasses(jarUrlPath: String, targetPackage: String, packagePath: String, functionName: String): Any? {
    val jarPath = jarUrlPath.substringAfter("file:").substringBefore("!")
    JarFile(jarPath).use { jarFile ->
        jarFile.entries().asSequence().forEach { entry ->
            val entryName = entry.name
            if (entryName.startsWith(packagePath) && entryName.endsWith(".class")) {
                val className = entryName.substringBeforeLast(".class").replace('/', '.')
                try {
                    val kClass = Class.forName(className).kotlin
                    kClass.functions.firstOrNull {
                        it.name == functionName && it.parameters.isEmpty()
                    }?.let { return it.call() }
                } catch (_: Exception) {
                    // 跳过加载失败的类
                }
            }
        }
    }
    return null
}

// 调用示例
fun main() {
    val result = findAndCallTopLevelFunction("com.example", "myFunction")
    println(result) // 输出: result
}

说明 #

• 该方法会遍历目标包下的所有类（包括本地目录和Jar包中的类）
• 检查每个类是否包含指定名称的无参顶层函数，找到后立即调用并返回结果
• 对类加载异常做了捕获处理，避免程序崩溃

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