Kotlin-＞Kotlin反射调用成员方法，静态方法，注解方法

Kotlin反射调用成员方法

class MyClass {
    fun MyMethod(param1: String, param2: Int): String {
        return "Called Method with param1: $param1, param2: $param2"
    }
}

fun myMemberMethodInvoke(target: Class<*>, methodName: String, parameterTypes: Array<Class<*>>, vararg args: Any?) {
    try {
        // 反射调用无参构造方法
        val newInstance = target.getDeclaredConstructor().newInstance()
        // 反射获取成员方法名称
        val method: Method = target.getDeclaredMethod(methodName, *parameterTypes)
        // 设置方法可访问
        method.isAccessible = true
        // 反射调用方法
        val result = method.invoke(newInstance, *args)
        println("Method result: $result")
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

fun main() {
	val methodName = "MyMethod"
	val parameterTypes = arrayOf<Class<*>>(String::class.java, Int::class.java)
	val args = arrayOf<Any?>("Hello", 123)
	myMemberMethodInvoke(MyClass::class.java, methodName, parameterTypes, *args)
}

// log result
Method result: Called Method with param1: Hello, param2: 123

Kotlin反射调用静态方法

class MyClass {
    companion object {
        @JvmStatic
        fun MyStaticMethod(param1: String, param2: Int): String {
            return "Called StaticMethod with param1: $param1, param2: $param2"
        }
    }
}

fun myStaticMethodInvoke(target: Class<*>, methodName: String, parameterTypes: Array<Class<*>>, vararg args: Any?) {
    try {
        // 反射调用静态方法，不需要创建实例
        val method = target.getDeclaredMethod(methodName, *parameterTypes)
        val result = method.invoke(null, *args)
        println("Static Method Result: $result")
    } catch (e: Exception) {
        println("Exception: $e")
    }
}

fun main() {
    // 反射调用静态方法
    val staticMethodName = "MyStaticMethod"
    val parameterTypes = arrayOf<Class<*>>(String::class.java, Int::class.java)
    val args = arrayOf<Any?>("Hello", 123)
    myStaticMethodInvoke(MyClass::class.java, staticMethodName, parameterTypes, *args)
}

// log result
Static Method Result: Called StaticMethod with param1: Hello, param2: 123

Kotlin反射调用注解方法

// 自定义注解
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation

class MyClass {
    @MyAnnotation
    fun MyAnnotatedMethod(param1: String, param2: Int): String {
        return "Called Annotated Method with param1: $param1, param2: $param2"
    }
}

fun myAnnotationMethodInvoke(target: Class<*>, methodName: String, parameterTypes: Array<Class<*>>, vararg args: Any?) {
    try {
        val method: Method = target.getDeclaredMethod(methodName, *parameterTypes)
        // 检查方法是否有自定义注解
        if (method.isAnnotationPresent(MyAnnotation::class.java)) {
            val instance = target.getDeclaredConstructor().newInstance()
            val result = method.invoke(instance, *args)
            println("Annotated Method Result: $result")
        }
    } catch (e: Exception) {
        println("Exception: $e")
    }
}

fun main() {
    val annotationMethodName = "MyAnnotatedMethod"
    val parameterTypes = arrayOf<Class<*>>(String::class.java, Int::class.java)
    val args = arrayOf<Any?>("Hello", 123)
    myAnnotationMethodInvoke(MyClass::class.java, annotationMethodName, parameterTypes, *args)
}

// log result
Annotated Method Result: Called Annotated Method with param1: Hello, param2: 123