Kotlin学习手记——反射

最新推荐文章于 2024-06-22 09:23:12 发布

2401_83641360

最新推荐文章于 2024-06-22 09:23:12 发布

阅读量1k

点赞数 13

分类专栏：程序员文章标签： kotlin 学习开发语言

本文链接：https://blog.csdn.net/2401_83641360/article/details/136983971

版权

程序员专栏收录该内容

505 篇文章 3 订阅

订阅专栏

// 能得到：age, name

println(A::class.declaredMemberProperties) 获取到所有定义的属性当前类

// 能得到：foo()

println(A::class.declaredMemberFunctions) 获取到所有定义的方法（普通方法，非扩展方法，非静态方法）当前类

// 能得到：age, name, foo(), (String.)hello()

println(A::class.declaredMembers) 获取到所有定义的成员包括属性和方法（普通方法和扩展方法）当前类

// 能得到：foo(), (String.)hello()

println(A::class.declaredFunctions) 获取到所有定义的方法（普通方法和扩展方法）如果是java类可以获取父类的方法

// 能得到：(String.)hello()

println(A::class.declaredMemberExtensionFunctions) 获取定义在当前类的扩展方法

// 能得到：[]

println(A::class.declaredMemberExtensionProperties) 获取定义在当前类的扩展属性

}

可以看出以declared开头的方法基本上只能获取当前类的属性和方法，不带declared开头的方法则同时可以获取到父类的相关属性和方法。

还有一点需要注意的是，这里kotlin里面所指的扩展属性和扩展方法一般是指直接写在当前类中的其他类的扩展方法，如上面的A里面的String.hello()方法。如果是A类在某个地方定义的扩展方法是获取不到的，如上面的A.test()方法。这点跟java有点不一样。

nestedClasses获取内部类

B::class.nestedClasses//获取内部类

objectInstance获取object单例的实例，如果不是单例类则返回可能为null

B::class.objectInstance?.hello() //获取object实例

A::class.objectInstance?.foo() //如果类不是一个object, 则返回null

类内部的其他类如何获取外部类的实例对象：

class A {

fun String.hello(){

this 表示当前String对象

this@A 表示外部当前的class A对象

}

java也是一样，内部类获取外部类的实例时需要通过，A.this 获取

获取泛型实参:

1.获取接口某个方法的返回值类型的泛型参数

interface Api {

fun getUsers(): List

}

获取上面 Api 接口的 getUsers() 返回类型的泛型参数类 UserDTO

有几种方式，第一种是根据name来比较判断找到对应的方法：

//获取到 Api的getUsers() 方法通过 filter

val functions = Api::class.declaredFunctions.filter { it.name == “getUsers” }

val getUsers : KFunction<*> = functions.get(0)

getUsers.returnType.arguments.forEach {

println(“getUser的返回值泛型：${it}”)

}

//获取函数的返回值参数的泛型类型UserDTO 通过 first

Api::class.declaredFunctions.first { it.name == “getUsers” }

.returnType.arguments.forEach {

println(“getUser的返回值泛型：${it}”)

}

还可以直接通过函数引用获取 Api::getUsers 得到的就是一个KFunction

Api::getUsers.returnType.arguments.forEach {

println(“getUser的返回值泛型2：${it}”)

}

显然这种方式最简单了。

还可以通过java的反射方式来获取：

//Api::class.java是获取到对应java的class Class 然后可以调用java的反射方法获取泛型类型

Api::class.java.getDeclaredMethod(“getUsers”)

.genericReturnType.safeAs()?.actualTypeArguments?.forEach {

println(it)

}

//safeAs是定义的一个Any的扩展方法

fun Any.safeAs(): T? {

return this as? T

}

//safeAs扩展方法可以简写下面的代码，等价于上面的代码

(Api::class.java.getDeclaredMethod(“getUsers”)

.genericReturnType as ParameterizedType).actualTypeArguments?.forEach {

println(it)

}

只能说java的方式也可以，但是这种也太麻烦了。。还是全部用kotlin的方法吧，不然得各种强转各种判空？.

2.获取接口类的泛型

abstract class SuperType {

//kotlin反射方法获取

val typeParameter by lazy {

//this是实际运行子类型, supertypes拿到父类型，first是第一个父类型即SuperType，arguments获取到泛型参数列表，只有一个可以first(),

// first()方法返回的是KTypeProjection，KTypeProjection.type才返回KType

this::class.supertypes.first().arguments.first().type!!

}

//java反射方法获取

val typeParameterJava by lazy {

this.javaClass.genericSuperclass.safeAs()!!.actualTypeArguments.first()

}

open class SubType : SuperType()

获取上面 SubType类实现的SuperType接口类的泛型：

val subType = SubType()

subType.typeParameter.let(::println) // kotlin.String

subType.typeParameterJava.let(::println) // class java.lang.String java获取的永远是java类型的描述

关键代码就是这句：this::class.supertypes.first().arguments.first().type 这里的话主要注意这个this运行时是实际的子类型（OO多态），所以最后是可以直接强转的。

上面代码是只有一个父类，如果有多个父类，会有问题，需要修改一下：

abstract class SuperType {

val typeParameter2 by lazy {

//实际中，如果子类是open可继承的可能还会有子类，具体要看使用的类

//此时需要找到合适的父类再操作，可以根据名字去比较，这里示例直接判断不是空的

this::class.allSupertypes.first { it.arguments.isNotEmpty() }.arguments.first().type!!

//等价上面

//this::class.allSupertypes.filter{ it.arguments.isNotEmpty()}.first().arguments.first().type!!

}

open class SubType : SuperType()

class SubType2: SubType()

获取上面 SubType2类的父类实现的SuperType接口类的泛型：

val subType2 = SubType2()

subType2.typeParameter2.let(::println) // kotlin.String

实例：为数据类实现 DeepCopy

fun T.deepCopy(): T {

//是数据类data class 才拷贝

if(!this::class.isData){

return this

}

//primaryConstructor获取主构造器，因为执行到这里的是数据类肯定有主构造器，所以!!强转，不用判空

return this::class.primaryConstructor!!.let {

primaryConstructor ->

primaryConstructor.parameters.map { parameter ->

//(this::class as KClass)逆变转协变

val value = (this::class as KClass).memberProperties.first { it.name == parameter.name } //成员属性名和构造函数的参数名相等

.get(this)

//classifier先转成KClass，然后判断是否是数据类

if((parameter.type.classifier as? KClass<*>)?.isData == true){

parameter to value?.deepCopy() //如果value是数据类继续调用value的deepCopy()方法深拷贝递归

} else {

parameter to value // 如果value不是数据类直接返回，(K to V)是返回一个Pair对象

}

}.toMap() //Pair集合转Map集合

.let(primaryConstructor::callBy) //callBy调用构造函数构造对象， callBy需要一个Map<KParameter, Any?>参数就是当前的map对象

}

调用测试代码：

data class Person(val id: Int, val name: String, val group: Group)

data class Group(val id: Int, val name: String, val location: String)

fun main() {

val person = Person(

“hello”,

Group(

“Kotliner.cn”,

“China”

)

val copiedPerson = person.copy()

val deepCopiedPerson = person.deepCopy()

println(person === copiedPerson) //false

println(person === deepCopiedPerson) //false

println(person.group === copiedPerson.group) //true for shallow copy.

println(person.group === deepCopiedPerson.group) //false

println(deepCopiedPerson)

}

上面的例子中主要有几点需要注意的：

this::class.isData 判断是否是数据类 data class
this::class.primaryConstructor 获取主构造器，因为是数据类一定有主构造器，所以可以强转 !!
primaryConstructor.parameters let里面调用当前primaryConstructor对象的parameters获取所有的构造器参数
this::class as KClass<T> 逆变转协变，否则this.class返回一个协变点out T, 而get()方法接受一个逆变点，会报错
memberProperties.first { it.name == parameter.name } 数据类的特点是构造器的参数名和成员的属性名相等
parameter.type.classifier as? KClass<*> type参数需要调用classifier先转成KClass然后再判断是否是数据类
parameter to value?.deepCopy() 如果value是数据类继续调用value的deepCopy()方法深拷贝，这里是一个递归调用，K to V 是返回的一个 Pair对象
.toMap() 将Pair集合转Map集合
.let(primaryConstructor::callBy) 调用主构造器，callsBy是KCallable接口的方法，KFunction是KCallable的子类，因此所有的KFunction都可以调用callBy，callBy接受一个map参数正好就是let前面返回的结果。

这个例子有一个完整的开源库代码 KotlinDeepCopy 是由我参阅的学习资料的大神Bennyhuo所写的，但是貌似目前没什么issue, 慎用，可以当案例学习一下。

实例：实现 Model 映射

这个例子是实现一个拷贝工作，将一个对象里的字段赋值给另一个对象里面的同名字段，跟深拷贝的例子有点相似

//任意对象转其他对象（成员属性名相同）

inline fun <reified From : Any, reified To : Any> From.mapAs(): To {

//所有成员转成Map集合再调用下面的Map转对象方法即可

return From::class.memberProperties.map { it.name to it.get(this) }

.toMap().mapAs()

}

//Map转对象（成员属性名相同）默认只处理数据类

inline fun Map<String, Any?>.mapAs(): To {

//primaryConstructor反射调用主构造器

return To::class.primaryConstructor!!.let {

it.parameters.map {

parameter ->

// this[parameter.name] 有可能为null, 如果目标对象To的构造器参数类型可以接受null类型就直接返回一个null 否则抛异常

parameter to (this[parameter.name] ?: if(parameter.type.isMarkedNullable) null

else throw IllegalArgumentException(“${parameter.name} is required but missing.”))

}.toMap()

.let(it::callBy)//callBy调用主构造器构造出一个To类型的对象

}

第一个方法的实现实际上是调用第二个方法的，所以只需实现第二个方法即可，这里依然是先获取主构造器To::class.primaryConstructor，获取了主构造器之后拿到它的参数列表进行map操作，map里面依然是返回当前参数 parameter to value，to 操作符左边的是To对象的也就是目标对象， to 操作符右边的是当前调用.mapAs的map对象，因此通过this[parameter.name]访问它里面的同名参数的value值，但是这个值可能为null, 不为null就返回 ?: 左边它自身，为null还需一个处理就是如果To类型即目标类的构造函数的这个当前参数可接受可空类型，就直接传null, 否则抛异常。

调用测试代码：

data class UserVO(val login: String, val avatarUrl: String)

data class UserDTO(

var id: Int,

var login: String,

var avatarUrl: String,

var url: String,

var htmlUrl: String

)

fun main() {

val userDTO = UserDTO(

“world”,