Java 反射 VS Kotlin 反射

作者: fengzhizi715 | 来源:发表于2021-09-26 20:18 被阅读0次

pexels-2876033.jpg

Kotlin 跟 Java 可以无缝衔接，因此 Kotlin 能够使用 Java 的反射机制。另外，Kotlin 也有自己的反射机制，需要额外地引入 kotlin-reflect.jar。

implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

kotlin-reflect.jar 中包含 kotlin.reflect.full 和 kotlin.reflect.jvm。

kotlin.reflect.full 是主要的 Kotlin 反射 API
kotlin.reflect.jvm 用于 Kotlin 反射和 Java 反射的互操作。

Kotlin 反射的特性包含：

提供对属性和可空类型的访问权限，这是由于 Java 没有属性和可空类型的概念。
Kotlin 反射不是 Java 反射的替代品，而是功能的增强。
可以使用 Kotlin 反射来访各种基于 JVM 语言编写的代码。

下面以 Java 的反射和 Kotlin 的反射进行对比。

一. 类引用，获取 Class 对象

Java 获取 Class 对象的方式

Class.forName("完整的包名+类名")

Class<?> clazz = Class.forName("xxx.xxx.MyClass")

类名.class

Class<?> clazz = MyClass.class;

实例对象.getClass()

MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();

Kotlin 获取 Class 对象的方式

调用的类是 Java 类，需要添加 .java 后缀( KClass 的扩展属性 java)

val clazz = MyClass::class.java

添加 Java 实例对象的.javaClass后缀（Java 实例对象的扩展属性 javaClass）。

val obj = MyClass()
val clazz = obj.javaClass

调用的类是 Kotlin 类

val clazz = MyClass::class

此时 clazz 的类型是 KClass 类型，KClass 的一个实例表示对 Kotlin 类的引用。KClass 也是 Kotlin 反射 API 的主要入口。

在 Kotlin 中，字节码对应的类也是 kotlin.reflect.KClass。

Kotlin 的引用类有两种方式：类名::class和对象::class，它们获取的都是相同的 KClass 实例。

即处于同一个类加载器中，给定的类型只能返回一个 KClass 实例。即使多次尝试实例化 KClass，仍然只能获取同一对象的引用， Kotlin 不会创建新的引用。

二. 构造函数引用，获取类的构造函数

Java 获取类的构造函数

Java 在获取 Class 实例之后，可以获取其中的构造函数。Java 获取类的构造函数对应的是 java.lang.reflect.Constructor，有以下五种方式：

// 获取参数列表是 parameterTypes，访问 public 的构造函数
public Constructor getConstructor(Class[] parameterTypes)

// 获取所有 public 构造函数
public Constructor[] getConstructors()

// 获取参数列表是 parameterTypes，并且是类自身声明的构造函数，访问控制符包含 public、protected 和 private 的函数。
public Constructor getDeclaredConstructor(Class[] parameterTypes)

// 获取类自身声明的全部的构造函数，包含 public、protected和private 的函数。
public Constructor[] getDeclaredConstructors()

// 如果类声明在其它类的构造函数中，返回该类所在的构造函数，如果存在则返回，不存在返回null
public Constructor getEnclosingConstructor()

Kotlin 获取类的构造函数

Kotlin 在获取 KClass 实例之后，可以获取它的全部构造函数。

// 类中声明的所有构造函数。
public val constructors: Collection<KFunction<T>>

Kotlin 通过::操作符并添加类名来引用构造函数。例如：

class Foo()

fun function(action: () -> Foo) {
    val foo: Foo = action.invoke()
    println(foo) // Foo@66d3c617
}

fun main() {
    function(::Foo)
}

对于含有参数的构造函数，也一样适用：

class Foo(val x:String)

fun main() {
    val foo = ::Foo // 表示引用 Foo 类的构造函数
    val f = foo("test")
    println(f)
}

三. 函数引用，获取类的成员函数

Java 获取类的成员函数

Java 获取类的成员函数对应的是 java.lang.reflect.Method，有以下五种方式：

// 根据函数名 name，参数 parameterTypes 获取类自身的 public 的函数(包括从基类继承的、从接口实现的所有 public 函数)
public Method getMethod(String name, Class[] parameterTypes)

// 获取全部 public 的函数(包括从基类继承的、从接口实现的所有 public 函数)
public Method[] getMethods()

// 根据函数名 name，参数 parameterTypes，获取类自身声明的函数，包含 public、protected 和 private 方法。
public Method getDeclaredMethod(String name, Class[] parameterTypes)

// 获取类自身声明的函数，包含 public、protected 和 private 方法。
public Method[] getDeclaredMethods()

// 如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 Method 对象，它表示底层类的立即封闭方法。若不存在，返回 null。
public Method getEnclosingMethod()

Kotlin 获取类的成员函数

Kotlin 通过反射调用函数，需要 KFunction 实例。KFunction 实例可以通过两种方式获得：一种是方法引用，另一种是通过 KClass 提供的 API 获得 KFunction 实例。

方法引用是简化版本的 Lambda 表达式，它和 Lambda 表达式拥有相同的特性。

Kotlin 和 Java 的方法引用使用::操作符，Kotlin 除了可以引用类中成员函数、扩展函数还可以引用顶层(top-level)函数。

方法引用属于 KFunction 的子类型 KFunctionN，N 代表具体的参数数量，例如 KFunction2<T1, T2, R>。KFunction 与 Lambda 的 Function 类似，都可以通过invoke()方法调用该引用函数。

例如：

val sum = {
        x: Int, y: Int -> x + y
}

fun sumFunction(x: Int, y: Int) = x + y

fun main() {
    println(sum(3,5))

    val sunFunc:KFunction2<Int,Int,Int> = ::sumFunction
    println(sunFunc.invoke(3,5))

    println(sunFunc.call(3, 5))
}

执行结果：

8
8
8

KFunctionN 类型属于合成的编译器生成类型，我们无法在包 kotlin.reflect 中找到它们的声明。

在上述例子中，最后一行代码：

println(sunFunc.call(3, 5))

其实这里调用 KCallable 接口的call()方法。

public actual interface KCallable<out R> : KAnnotatedElement {

    ......

    /**
     * Calls this callable with the specified list of arguments and returns the result.
     * Throws an exception if the number of specified arguments is not equal to the size of [parameters],
     * or if their types do not match the types of the parameters.
     */
    public fun call(vararg args: Any?): R

    ......
}

对于 KFunction 对象，也可以使用 KCallable 的call()方法来调用被引用的函数。call()方法使用指定的参数列表，开发者需要自行匹配所使用的实参类型和数量，如果其类型与参数的类型不匹配，则会引发异常。

而 KFunctionN 的invoke()方法的形参类型和返回值类型是可以确定的，调用它的 invoke() 时编译器会帮我们做检查。

当然，也可以使用 KFunctionN 来引用类的扩展函数。引用扩展函数的用法跟引用成员函数的用法是一致的。

data class User(var name:String,var password:String)

fun User.validatePassword():Boolean = this.password.length > 6

val validate:KFunction1<User,Boolean> = User::validatePassword

fun main() {

    val user = User("tony","12345")
    println(user.validatePassword())
    println(validate.invoke(user))
    println(validate.call(user))
}

四. 属性引用，获取类的成员变量

Java 获取类的成员变量

Java 获取类的成员变量对应的是 java.lang.reflect.Field，有以下四种方式：

// 获取相应的类自身声明的 public 成员变量(包括从基类继承的、从接口实现的)
public Field getField(String name)

// 获取类自身声明全部的 public 成员变量(包括从基类继承的、从接口实现的)
public Field[] getFields()

// 获取相应的类自身声明的成员变量，包含 public、protected 和 private 成员变量。
public Field getDeclaredField(String name)

// 获取类自身声明的成员变量，包含 public、protected 和 private 。
public Field[] getDeclaredFields()

Kotlin 获取类的属性

Kotlin 没有成员变量的概念，只有属性的概念。下面展示了引用不同属性的方式。

不可变属性的引用

Kotlin 使用::属性来获取不可变属性的引用，并返回 KProperty<V> 类型的值。它的get()方法会返回属性的值，它的name属性会返回可变属性的名称。

val x = 1
val y = "hello"

fun main() {
    println(::x)
    println(::x.get())
    println(::x.name)
    println(::y)
    println(::y.get())
    println(::y.name)
}

执行结果：

val x: kotlin.Int
1
x
val y: kotlin.String
hello
y

可变属性的引用

Kotlin 使用::属性来获取可变属性的引用，并返回 KMutableProperty<V> 类型的值。它除了上述的get()方法、name属性，还支持set()方法修改属性的值。

var x = 1
var y = "hello"

fun main() {
    println(::x)
    ::x.set(0)
    println(::x.get())
    println(::x.name)
    println(::y)
    ::y.set("world")
    println(::y.get())
    println(::y.name)
}

执行结果：

var x: kotlin.Int
0
x
var y: kotlin.String
world
y

扩展属性的引用

Kotlin 使用类名::属性来获取扩展属性的引用，并返回 KProperty1<T, out V> 类型的值。它的get()、getValue()方法会返回扩展属性的值。

class Extension

val Extension.x: Int
    get() = 1

fun main() {
    println(Extension::x) // Extension.x: kotlin.Int
    val extension = Extension()
    println(Extension::x.get(extension)) // 1
    println(Extension::x.getValue(extension,Extension::x)) // 1
}

类的成员属性的引用

Kotlin 使用类名::属性来获取成员属性的引用，并返回 KProperty1<T, out V> 类型的值。它的get()、call()方法会返回成员属性的值。

class Bar1(val x: Int)
class Bar2(val x: Int,val y:String)

fun main() {
    val bar1 = Bar1(1)
    val prop = Bar1::x
    println(prop.call(bar1))
    println(prop.getter.call(bar1))
    println(prop.get(bar1))

    val bar2 = Bar2(2,"test")
    val propX = Bar2::x
    val propY = Bar2::y
    println(propX.call(bar2))
    println(propY.call(bar2))
    println(propX.get(bar2))
}

执行结果：

1
1
1
2
test
2

另外，这里的call()方法，依然是 KCallable 接口的call()方法。call()方法的调用最终会调用该属性的 getter 属性。

毕竟，KProperty、KFunction 的超类型都是 KCallable

五. 获取类的其它信息

Java 获取类的其它信息

Java 获取类的注解信息，对应的是 java.lang.annotation.Annotation 接口，有以下三种方式：

// 获取类的 annotationClass 类型的注解 (包括从基类继承的、从接口实现的所有 public 成员变量)
public Annotation<A> getAnnotation(Class annotationClass)

// 获取类的全部注解 (包括从基类继承的、从接口实现的所有 public 成员变量)
public Annotation[] getAnnotations()

// 获取类自身声明的全部注解 (包含 public、protected 和 private 成员变量)
public Annotation[] getDeclaredAnnotations()

Java 获取类的接口和基类的信息，对应的是 java.lang.reflect.Type 接口，有以下两种方式：

// 获取类实现的全部接口
public Type[] getGenericInterfaces()

// 获取类的直接超类的 Type
public Type getGenericSuperclass()

Java 获取类的其它描述信息，包括：

// 获取类名
public String getSimpleName()

// 获取完整类名
public String getName()

// 判断类是不是枚举类
public boolean isEnum()

// 判断obj是不是类的实例对象
public boolean isInstance(Object obj)

// 判断类是不是接口
public boolean isInterface()

// 判断类是不是局部类。局部类所属范围：在块、构造器以及方法内，这里的块包括普通块和静态块。
public boolean isLocalClass()

// 判断类是不是成员类
public boolean isMemberClass()

// 判断类是不是基本类型。
public boolean isPrimitive()

Kotlin 获取类的其它信息

Kotlin 能够获取更多的类的信息，包括：

// 获取类的名字
public val simpleName: String?

 // 获取类的全包名
public val qualifiedName: String?

// 如果这个类声明为 object，则返回其实例，否则返回 null
public val objectInstance: T?

// 获取类的可见性
@SinceKotlin("1.1")
public val visibility: KVisibility?

// 判断类是否为 final 类，Kotlin 默认类是 final 类型的，除非这个类声明为 open 或者 abstract
@SinceKotlin("1.1")
public val isFinal: Boolean

// 判断类是否是open，(abstract  类也是 open），表示这个类可以被继承
@SinceKotlin("1.1")
public val isOpen: Boolean

// 判断类是否为抽象类
@SinceKotlin("1.1")
public val isAbstract: Boolean

// 判断类是否为密封类
@SinceKotlin("1.1")
public val isSealed: Boolean

// 判断类是否为 data class
@SinceKotlin("1.1")
public val isData: Boolean

// 判断类是否为成员类
@SinceKotlin("1.1")
public val isInner: Boolean

// 判断类是否为 companion object
@SinceKotlin("1.1")
public val isCompanion: Boolean

// 判断类是否为 functional interface
@SinceKotlin("1.4")
public val isFun: Boolean

// 获取类中定义的其他类，包括内部类和嵌套类
public val nestedClasses: Collection<KClass<*>>

// 判断一个对象是否为此类的实例
@SinceKotlin("1.1")
public fun isInstance(value: Any?): Boolean

// 获取这个类的泛型列表
@SinceKotlin("1.1")
public val typeParameters: List<KTypeParameter>

// 获取类其直接基类的列表
@SinceKotlin("1.1")
public val supertypes: List<KType>

// 如果该类是密封类，返回子类的列表，否则返回空列表。
@SinceKotlin("1.3")
public val sealedSubclasses: List<KClass<out T>>

// 获取类所有的基类
val KClass<*>.allSuperclasses: Collection<KClass<*>>

// 获取类的伴生对象 companionObject
val KClass<*>.companionObject: KClass<*>?

六. Java 反射与 Kotlin 反射的互操作性

为一个 Kotlin 属性获取一个 Java 的 getter/setter 方法或者幕后字段，需要使用 kotlin.reflect.jvm 包。

幕后字段 (backing field) 是 Kotlin 属性自动生成的字段，它只能在当前属性的访问器(getter、setter)内部使用。

KProperty 的扩展属性 javaGetter：返回给定属性的 getter 相对应的 Java 方法实例，如果该属性没有 getter，则返回 null。

val KProperty<*>.javaGetter: Method?
    get() = getter.javaMethod

KProperty 的扩展属性 javaField：返回给定属性的幕后字段相对应的 Java 字段实例，如果属性没有幕后字段，则返回 null。

val KProperty<*>.javaField: Field?
    get() = this.asKPropertyImpl()?.javaField

KMutableProperty 的扩展属性 javaSetter：返回给定可变属性的 setter 相对应的 Java 方法实例，如果该属性没有 setter，则返回 null。

val KMutableProperty<*>.javaSetter: Method?
    get() = setter.javaMethod

如果要获取对应于 Java 的 Kotlin 类，使用 .kotlin 扩展属性返回 KClass 实例。

public val <T : Any> Class<T>.kotlin: KClass<T>
    @JvmName("getKotlinClass")
    get() = Reflection.getOrCreateKotlinClass(this) as KClass<T>

Java 反射 VS Kotlin 反射

一. 类引用，获取 Class 对象

Java 获取 Class 对象的方式

Kotlin 获取 Class 对象的方式

二. 构造函数引用，获取类的构造函数

Java 获取类的构造函数

Kotlin 获取类的构造函数

三. 函数引用，获取类的成员函数

Java 获取类的成员函数

Kotlin 获取类的成员函数

四. 属性引用，获取类的成员变量

Java 获取类的成员变量

Kotlin 获取类的属性

不可变属性的引用

可变属性的引用

扩展属性的引用

类的成员属性的引用

五. 获取类的其它信息

Java 获取类的其它信息

Kotlin 获取类的其它信息

六. Java 反射与 Kotlin 反射的互操作性

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Kotlin 实战