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>