Kotlin 反射 #

// build.gradle.kts
dependencies {
    implementation("org.jetbrains.kotlin:kotlin-reflect:1.9.22")
}

// 使用 ::class
val stringClass = String::class

// 使用 javaClass
val obj = "Hello"
val klass = obj::class

// 使用 Class 转换
val javaClass = String::class.java
val kotlinClass = javaClass.kotlin

class Person(val name: String, var age: Int)

fun main() {
    val klass = Person::class
    
    println(klass.simpleName)      // Person
    println(klass.qualifiedName)   // com.example.Person
    println(klass.isData)          // false
    println(klass.isSealed)        // false
    println(klass.isAbstract)      // false
}

class Person(val name: String, var age: Int)

fun main() {
    val klass = Person::class
    
    // 使用主构造函数
    val person = klass.primaryConstructor?.call("Kotlin", 10)
    
    // 使用 createInstance（需要无参构造函数）
    // val instance = klass.createInstance()
}

class Person(val name: String) {
    fun greet() = "Hello, $name"
    
    fun greetWith(greeting: String) = "$greeting, $name"
}

fun main() {
    val person = Person("Kotlin")
    
    // 成员函数引用
    val greet = Person::greet
    println(greet.call(person))  // "Hello, Kotlin"
    
    // 绑定函数引用
    val boundGreet = person::greet
    println(boundGreet())  // "Hello, Kotlin"
}

fun add(a: Int, b: Int): Int = a + b

fun main() {
    val func = ::add
    
    println(func.name)           // add
    println(func.parameters)     // [a, b]
    println(func.returnType)     // kotlin.Int
}

fun add(a: Int, b: Int): Int = a + b

fun main() {
    val func = ::add
    
    // 直接调用
    val result1 = func.call(1, 2)  // 3
    
    // 按名称调用
    val result2 = func.callBy(mapOf(
        func.parameters[0] to 1,
        func.parameters[1] to 2
    ))
}

class Person(var name: String, val age: Int)

fun main() {
    val person = Person("Kotlin", 10)
    
    // 属性引用
    val nameProp = Person::name
    println(nameProp.get(person))  // Kotlin
    
    // 绑定属性引用
    val boundName = person::name
    println(boundName.get())  // Kotlin
    
    // 修改属性
    nameProp.set(person, "Java")
    println(person.name)  // Java
}

class Person(val name: String, var age: Int)

fun main() {
    val klass = Person::class
    
    // 获取所有属性
    val properties = klass.memberProperties
    
    properties.forEach { prop ->
        println("${prop.name}: ${prop.returnType}")
        println("Is mutable: ${prop is KMutableProperty1}")
    }
}

class Example {
    val lazyValue: String by lazy { "Lazy" }
}

fun main() {
    val prop = Example::lazyValue
    
    // 检查是否是延迟属性
    val delegate = prop.getDelegate(Example())
    println(delegate is Lazy<*>)  // true
}

class Service {
    fun method1() { }
    fun method2(param: String) { }
    private fun privateMethod() { }
}

fun main() {
    val klass = Service::class
    
    // 所有公开成员函数
    klass.memberFunctions.forEach { func ->
        println(func.name)
    }
    
    // 所有声明的函数（包括私有）
    klass.declaredMemberFunctions.forEach { func ->
        println(func.name)
    }
}

class User(
    val id: Int,
    var name: String,
    private var password: String
)

fun main() {
    val klass = User::class
    
    klass.memberProperties.forEach { prop ->
        println("${prop.name}: ${prop.returnType}")
    }
}

class Person(val name: String) {
    constructor(name: String, age: Int) : this(name)
}

fun main() {
    val klass = Person::class
    
    // 主构造函数
    println(klass.primaryConstructor)
    
    // 所有构造函数
    klass.constructors.forEach { ctor ->
        println(ctor.parameters)
    }
}

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Table(val name: String)

@Table("users")
class User

fun main() {
    val annotation = User::class.findAnnotation<Table>()
    println(annotation?.name)  // users
}

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String)

class User(
    @Column("user_name")
    val name: String
)

fun main() {
    val prop = User::class.memberProperties.find { it.name == "name" }
    val annotation = prop?.findAnnotation<Column>()
    println(annotation?.name)  // user_name
}

inline fun <reified T : Any> T.copyFrom(source: T): T {
    val klass = T::class
    val constructor = klass.primaryConstructor ?: return this
    
    val args = constructor.parameters.associateWith { param ->
        val prop = klass.memberProperties.find { it.name == param.name }
        prop?.get(source) ?: param.defaultValue?.invoke()
    }
    
    return constructor.callBy(args)
}

fun <T : Any> T.toMap(): Map<String, Any?> {
    return this::class.memberProperties.associate { prop ->
        prop.name to prop.getter.call(this)
    }
}

fun <T : Any> Map<String, Any?>.toObject(klass: KClass<T>): T {
    val constructor = klass.primaryConstructor!!
    val args = constructor.parameters.associateWith { param ->
        this[param.name]
    }
    return constructor.callBy(args)
}

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val tableName: String = "")

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Id

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String = "")

@Entity("users")
data class User(
    @Id
    @Column("id")
    val id: Long,
    
    @Column("name")
    val name: String
)

fun <T : Any> insert(entity: T) {
    val klass = entity::class
    val tableName = klass.findAnnotation<Entity>()?.tableName ?: klass.simpleName!!
    
    val columns = klass.memberProperties
        .filter { it.findAnnotation<Id>() == null }
        .map { prop ->
            val columnName = prop.findAnnotation<Column>()?.name ?: prop.name
            columnName to prop.getter.call(entity)
        }
    
    val sql = "INSERT INTO $tableName (${columns.joinToString { it.first }}) VALUES (${columns.joinToString { "?" }})"
    println(sql)
}

val propertyCache = mutableMapOf<KClass<*>, Collection<KProperty1<*, *>>>()

fun <T : Any> getProperties(klass: KClass<T>): Collection<KProperty1<T, *>> {
    return propertyCache.getOrPut(klass) {
        klass.memberProperties
    } as Collection<KProperty1<T, *>>
}

inline fun <reified T : Any> create(): T {
    return T::class.createInstance()
}

fun safeCall(func: KFunction<*>, vararg args: Any?): Result<Any?> {
    return try {
        Result.success(func.call(*args))
    } catch (e: Exception) {
        Result.failure(e)
    }
}