Kotlin 元编程（注解，反射）

元编程简介

元编程：代码在‘编译期’或‘运行时’ 生成或改变代码的一种‘编程形式’。

编写‘元程序’的语言称作‘元语言’，被操纵的语言称作‘目标语言’。

‘反射’是指，一门语言同时具备既是‘元语言’又是‘目标语言’的能力。

一般代码的操作对象是‘数据’，元编程的操作对象是‘其他代码’，无关业务逻辑，只跟当前代码结构相关的代码。

元编程是一种对‘源代码’本身进行‘高层次抽象’的编码技术。
就是用代码中的元数据（注解）来动态插入新代码逻辑，动态生成代码的程序。

注解是给代码添加的元数据。
使用注解可以写出简洁、干净的代码，同时可以在编译期进行类型检查。
Kotlin 注解完全兼容 Java 注解。

反射是在‘运行时’获取类的函数、属性、父类、接口、注解元数据、泛型信息 等类的内部信息的机制。
（运行时类型信息）

注解

/**
 * 声明注解 Run
 */
@MustBeDocumented
@Repeatable
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
    AnnotationTarget.VALUE_PARAMETER)
@Retention(AnnotationRetention.RUNTIME)
annotation class Run

/**
 * 声明注解 TestCase
 */
@MustBeDocumented
@Repeatable
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
    AnnotationTarget.VALUE_PARAMETER)
@Retention(AnnotationRetention.RUNTIME)
annotation class TestCase(val id: String)

注解是一种class，编译器可以对注解在编译期进行类型检查。
自定义的注解使用到的注解（@Target、@Retention、@Repeatable、@MustBeDocumented），称作元注解。使用元注解向自定义的注解类来指定属性。

• @Target ：指定该注解可以被用于哪些元素。

  • AnnotationTarget.CLASS 类
  • AnnotationTarget.ANNOTATION_CLASS 注解类
  • AnnotationTarget.TYPE_PARAMETER 泛型参数
  • AnnotationTarget.PROPERTY 属性
  • AnnotationTarget.FIELD 成员变量
  • AnnotationTarget.FUNCTION 函数
  • AnnotationTarget.LOCAL_VARIABLE 局部变量
  • AnnotationTarget.TYPE 类、接口、注解类型、enum
  • AnnotationTarget.EXPRESSION 表达式
  • AnnotationTarget.FILE 文件
  • AnnotationTarget.TYPEALIAS 类型别名
  • 等等，还有其他区域（元素）。

• @Retention ：指定该注解信息是否保存到编译后的 class 文件中，在运行时是否可以通过反射访问到它。

  • AnnotationRetention.SOURCE 注解数据不存储在二进制输出中
  • AnnotationRetention.BINARY 注解数据保存在二进制输出中，但反射不可见
  • AnnotationRetention.RUNTIME 注解数据保存在二进制输出中，同时反射可用（默认）

• @Repeatable ：允许在某个元素上多次使用同一个注解

• @MustBeDocumented ：表面该注解是公开 API 的一部分，在自动生成的 API 文档/函数签名中，包含该注解的信息。

/**
 * 使用注解 Run、TestCase
 */
@Run
class AnnoxTest {
    @TestCase(id = "0x001")
    fun testF(tId: String): Unit {
        println("AnnoxTest ID = $tId")
    }
}

/**
 * 处理注解
 */
fun annoProcessingF(): Unit {
    val tx = AnnoxTest()
    val kClaz= tx::class // 使用 ::class 来获取对象tx 的类信息
    println(kClaz)
    val declaredFunz = kClaz.declaredFunctions // 获取该类型声明的所有函数
    println(declaredFunz)

    for (f in declaredFunz) {
        val annoZ = f.annotations // annotations属性 存储了该函数所有的注解信息
        println("annotations: ${annoZ.size}")
        annoZ.forEach {
            println(it.annotationClass)
            if (it is TestCase) { // 处理 TestCase 注解，获取其中的元数据
                val id = it.id
                handleParam(id)
                f.call(tx, id) // 使用call()函数 —— 通过反射来调用原函数
                // f.javaMethod?.invoke(tx, id) // 通过反射来调用原函数
            }
        }
    }
}

fun handleParam(id: String) {
    println("handle param in annoProcessingF : $id , ${Date()}")
}

// 测试
fun main(args: Array<String>) {
    annoProcessingF()
}

反射

类引用

反射 是在运行时获取一个类引用。

open class BaseBox<T>

class Box<T: Comparable<T>> : BaseBox<Int> {
    var data: MutableList<T>
    constructor(elements: MutableList<T>) {
        this.data = elements
    }

    fun sort(): Box<T> {
        this.data.sort()
        return this
    }

    override fun toString(): String {
        return "Box{elements= $data}"
    }
}

fun testClazzReflect(): Unit {
    val list = mutableListOf(1,3,9,6,6)
    println(list::class)
    val box = Box(list)
    box.sort()
    println(box.toString())
    val kClazz = box::class // 使用 ::class 获取box的KClass对象
    println("kotlin class: $kClazz")
    val jClazz = box.javaClass // 获取Java类的引用
    println("java class: $jClazz")
    println(kClazz.java) // 获取Java类的引用
}

fun testKClazzReflectF(): Unit {
    val list = mutableListOf(1,3,9,6,6)
    val box = Box(list)
    val kClazz = box::class // 获取 box 的 KClass对象

    val typeParams = kClazz.typeParameters // 获取泛型信息
    println(typeParams) // [T]
    val kTypeParam = typeParams[0] // 取第一个泛型对象
    println(kTypeParam) // T
    println(kTypeParam.isReified) // false
    println(kTypeParam.name) // T
    println(kTypeParam.upperBounds) // [kotlin.Comparable<T>]
    println(kTypeParam.variance) // INVARIANT

    val constructors = kClazz.constructors // 获取构造函数信息
    for (kFunc in constructors ) {
        val params = kFunc.parameters // 构造函数的参数集合
        params.forEach {
            val name = it.name
            val type = it.type
            println("name= $name") // name= elements
            println("type= $type") // type= kotlin.collections.MutableList<T>
            for (projection in type.arguments) {
                println("argument: ${projection.type}") // argument: T
            }
        }
    }
}

函数引用

fun isOdd(x: Int): Boolean {
    return x%2!=0
}

fun testFuncReflect(): Unit {
	// 直接调用函数
    println(isOdd(9))   // true
    println(isOdd(2))   // false

    val nums = listOf(1,3,6)
    // 将函数作为参数使用
    val data = nums.filter( ::isOdd ) // 在高阶函数中使用 函数isOdd 作为参数
		// ::isOdd 是一个函数类型的参数 (Int)->Boolean
    println(data)   // [1, 3]
}

属性引用

var nickName = "Sermon"

fun testPropertyReflect(): Unit {
    println(::nickName.get()) // Sermon

    ::nickName.set("David")
    println(::nickName.get()) // David
    println(nickName) // David
}

绑定函数和属性引用

fun testBoundFuncAndPropertyReflect(): Unit {
    val regex = "\\d+".toRegex()
    val a0 = regex.matches("9") // true
    val b0 = regex.matches("3") // true
    val c0 = regex.matches("Z") // false
    println("$a0, $b0, $c0")

    val isDigit = regex::matches // 直接引用regex对象的matches()方法
    val a1 = isDigit("9") // true
    val b1 = isDigit("3") // true
    val c1 = isDigit("Z") // false
    println("$a1, $b1, $c1")
}