注解处理器的编写（Kotlin）

注解处理器的的作用

注解处理器可以在编译时对@Retention值为AnnotationRetention.BINARY(kotlin)\RetentionPolicy.CLASS(java)的注解进行处理 ，实现对注解所在代码的处理，例如打印日志、生成代码等。是实现面向切面编程(AOP)的一种方式。

编写方式

目标

目标

通过注解对person进行实例化，并赋值。

实现

Demo是一个安卓项目。

目录结构

标记3个部分是javaLibray，作用分别是：

• annotation：注解所在类
• complier：注解处理器所在类
• runtime:用于直接调用的类

PS:app在依赖着三个的模块的时候，对complier不要使用api或implementation,而是使用kapt。

依赖

annotation部分

首先是在创建一个注解。

@Retention(value = AnnotationRetention.BINARY)
@Target(AnnotationTarget.FIELD)
annotation class Binding(val text: String) 

这段代码的主要有两个注解一个是@Retention，作用就是在什么情况下保留，选择在编译时保留。@Target为了方便选择目标是Field。传入参数的话是用于给person赋值使用。

complier部分

这部分主要就是注解处理的具体部分。

class BindProcessor : AbstractProcessor() {
    //用于打印消息
    private lateinit var messager: Messager
    //处理Element的工具类
    private lateinit var elementUtils: Elements
    //用于输出文件
    private lateinit var filer: Filer
    //Type工具类
    private lateinit var typeUtils: Types
    override fun process(
        annotations: MutableSet<out TypeElement>,
        roundEnv: RoundEnvironment
    ): Boolean {  
        //获取到被binding标记的元素
        roundEnv.getElementsAnnotatedWith(Binding::class.java).filter { it.kind.isField }.forEach {
            val variableElement = it as VariableElement
            val packageOf = elementUtils.getPackageOf(variableElement)
            val annotation = variableElement.getAnnotation(Binding::class.java)
            var element: Element = variableElement
            while (element.kind != ElementKind.CLASS) {
                element = element.enclosingElement
            }
            kotlin.runCatching {
                CodeProcess(
                    variableElement,
                    packageOf,
                    element as TypeElement,
                    annotation.text
                ).createCode(filer)
            }.onFailure { e ->
                messager.printMessage(Diagnostic.Kind.WARNING, e.localizedMessage)
            }
        }

        return true

    }

    override fun init(processingEnv: ProcessingEnvironment) {
        super.init(processingEnv)
        typeUtils = processingEnv.typeUtils
        elementUtils = processingEnv.elementUtils
        filer = processingEnv.filer
        messager = processingEnv.messager

    }

    //标记支持的版本
    override fun getSupportedSourceVersion(): SourceVersion {
        return SourceVersion.latestSupported()
    }
    
     //添加支持的注解有哪些
    override fun getSupportedAnnotationTypes(): MutableSet<String> {
        val annotations: MutableSet<String> = LinkedHashSet()
        annotations.add(Binding::class.java.canonicalName)
        return annotations
    }

}

代码中可以看到主要重写的4个方法

• process
  为对注解进行处理的核心方法
• init
  在调用注解处理器时会执行的方法
• getSupportedSourceVersion
  用于确定支持的java版本
• getSupportedAnnotationTypes

process的主要过程就是
1.获取注解
2.对注解进行分类，获取注解标记的对应属性，类，方法等。
3.对获取到的信息进行处理，就本Demo而言，就是通过filer输出用于创建的类。代码通过CodeProcess类来处理信息

class CodeProcess(
    val element: VariableElement,
    pack: PackageElement,
    type: TypeElement,
    var text: String
) {
    var name: String = element.simpleName.toString()
    var packNameString: String = pack.toString()
    var codeClazzName = type.simpleName.toString() + "Binding"
    fun createCode(filer: Filer) {
        //创建方法
        val methodBuild = MethodSpec.methodBuilder("create")
            .addModifiers(Modifier.PUBLIC, Modifier.STATIC)   //设置为公开的静态方法
            .returns(ClassName.get(element.asType()))    //输入返回值类型
            .addStatement(" return new \$T(\$S)", ClassName.get(element.asType()), text)  //加入代码语句
            .build()
        //创建class
        val typeBuild = TypeSpec.classBuilder(codeClazzName)
            .addModifiers(Modifier.PUBLIC)
            .addMethod(methodBuild)
            .build()
        //输出java文件
        JavaFile.builder(packNameString, typeBuild)
            .build()
            .writeTo(filer)

    }

    override fun toString(): String {
        return "CodeProcess(element=$element, text='$text', name='$name', packNameString='$packNameString', codeClazzName='$codeClazzName')"
    }
}

代码创建java文件，使用的时JavaPoet，具体的使用方法可以查看GitHub。其中$T、$S分别是类型和支付字符串的替换占位符。
在上面代码完成以后,需要把注解处理器注册到编译器中。方式是在创建 resources文件。并在内创建META-INF、service、javax.annotation.processing.Processor文件。然后在javax.annotation.processing.Processor内添加，注解处理器的完整名称(包名+类名)。

注册注解处理器
注册内容

runtime部分

这一部分的主要目的就是提供一个对外的统一调用的方法。对于本Demo来说，就是他通过反射对注解标注的属性进行实例化和赋值。

class BindingData {
    companion object {

        @JvmStatic
        fun bind(any: Any) {
            val bindingName = any.javaClass.name + "Binding"
            print(bindingName)
            val clazz = Class.forName(bindingName)
            val invoke = clazz.getMethod("create").invoke(null)//调用静态方法
            val fields = any.javaClass.fields
            fields.filter { it.type == invoke.javaClass }.forEach {
                it.isAccessible = true
                it.set(any, invoke)//对属性进行赋值
            }
        }
    }
}

结果

class MainActivity : AppCompatActivity() {
    @Binding("张三")
    lateinit var person: Person
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        BindingData.bind(this)
        val tv = findViewById<TextView>(R.id.tv)
        tv.setOnClickListener {
            tv.text = person.name
        }
    }
}

通过这一段文字就可以点击获取person的name。

注解处理器Demo地址