Java 反射 VS Kotlin 反射

简介: Java 反射 VS Kotlin 反射

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>


相关文章
|
11天前
|
Java 程序员 测试技术
解析Java中的反射机制及其应用场景
解析Java中的反射机制及其应用场景
|
13天前
|
开发框架 Java Android开发
Java中的类反射与动态代理详解
Java中的类反射与动态代理详解
|
15天前
|
缓存 Java 测试技术
Java中的反射机制及其应用场景
Java中的反射机制及其应用场景
|
15天前
|
Java
Java中的反射与动态代理机制详解
Java中的反射与动态代理机制详解
|
15天前
|
存储 安全 Java
Java中的反射机制及其应用场景详解
Java中的反射机制及其应用场景详解
|
17天前
|
安全 Java
JAVA反射:如何在运行时“创造”你的对象?
【7月更文挑战第1天】Java反射机制允许在运行时动态创建对象,常用于插件系统和框架开发。与`new`关键字相比,反射提供更大的灵活性,能根据条件决定对象类型,但牺牲了性能和代码可读性。示例展示了如何通过`Class.forName()`和`Constructor.newInstance()`创建对象,过程中需处理异常。反射还可访问私有成员,增加安全风险,故使用时需谨慎。
13 2
|
17天前
|
安全 Java 测试技术
Java中的反射与元编程技术探秘
Java中的反射与元编程技术探秘
|
9天前
|
Java API
Java注解与反射机制
Java注解与反射概述: - 注解用于元数据,包括元注解`@Target`, `@Retention`, `@Documented`, `@Inherited`。 - 自定义注解用于自定义行为标记,参考[链接]例化后通过`getClass()`获取类信息。 - 主要API涉及类的多种获取方式,如`对象.getClass()`, `类名.class`, `Class.forName()`和内置类型`TYPE`。 - 应用场景包括动态创建对象,获取泛型和注解信息以及分析运行时结构。
|
10天前
|
Java 程序员 测试技术
解析Java中的反射机制及其应用场景
解析Java中的反射机制及其应用场景
|
10天前
|
缓存 Java 测试技术
Java中的反射机制及其应用场景
Java中的反射机制及其应用场景