java 注解处理器_JAVA 插入注解处理器

JDK1.5后，Java语言提供了对注解(Annotation)的支持

JDK1.6中提供一组插件式注解处理器的标准API，可以实现API自定义注解处理器，干涉编译器的行为。

在这里,注解处理器可以看作编译器的插件，在编译期间对注解进行处理，可以对语法树进行读取、修改、添加任意元素；但如果有注解处理器修改了语法树，编译器将返回解析及填充符号表的过程，重新处理，直到没有注解处理器修改为止，每一次重新处理循环称为一个Round。

平时工作中，使用的注解,除了框架 等自带的注解，还有一些自定义的注解，而一般情况下使用自定义注解，主要是用来使用AOP对其

进行增强的。

而这篇博客所说的插件式注解处理器,是直接干预生成的字节码的文件的。

Java常用的Lombok , Android 常用的 ButterKnife 就属于此类，通过干预 Java的编译过程来达到代码增强的著名类库。

先简单描述一下Java文件的编译：

Java前端编译(Java三种编译方式：前端编译 JIT编译 AOT编译)：Java源代码编译成Class文件的过程

javac编译器是官方JDK中提供的前端编译器，JDK/bin目录下的javac只是一个与平台相关的调用入口，具体实现在JDK/lib目录下的tools.jar。此外，JDK6开始提供在运行时进行前端编译，默认也是调用到javac

javac是由Java语言编写的，而HotSpot虚拟机则是由C++语言编写；标准JDK中并没有提供javac的源码，而在OpenJDK中的提供

javac编译器程序入口：com.sun.tools.javac.Main类中的main()方法

我们先来了解下javac的编译过程，大致可以分为3个过程，分别是：

解析与填充符号表过程

插入式注解处理器的注解处理过程(jsr269规范)

分析与字节码生成过程

解析与填充符号表过程会将源码转换为一棵抽象语法树(Abstract Syntax Tree，AST)，AST是一种用来描述程序代码语法结构的树形表示方式，语法树的每一个节点都代表着程序代码中的一个语法结构(Construct)，例如包、类型、修饰符、运算符、接口、返回值甚至代码注释等都可以是一个语法结构。

因此可以利用Java的插入式注解处理器提供的API，读取、修改、添加抽象语法树中的任意元素。如果因为这些注解对语法树进行了修改，编译器会重新进行词法、语法的分析处理，直到所有的插入式注解没有对语法树进行修改为止。

那么，就以一个例子来说说这个插入式注解处理器：

平时工作中有时候需要查看一个方法的执行耗时,那么通常的做法是方法体前后通过两个时间戳变量来计算，这种情况对于单个方法使用，但是多个方法就显得比较麻烦了。当然也可以通过一些设计模式来解决这个问题

如果恰好使用Spring，那么使用AOP也可以解决这个问题！

但是说来说去，我就是想看一下方法的执行时间，上述的方法都太过麻烦！怎么才能方便的解决这个问题呢？

这里我先自定义一个注解

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.SOURCE)

@Documentedpublic @interfaceTakeTime {/*** 标记前缀,无实质作用,只是为了方便查找

*@return

*/String tag()default "";

}

这是一个非常简单的自定义注解,注解只能标注在方法上,同时注解的有效期只在@Retention(RetentionPolicy.SOURCE) 源码期

这里要说明的是,这个有效期在我这个demo中可以是任意值，因为本博客说的插入式注解处理器,不管注解的生命周期是什么值,插入式注解处理器都会进行处理。

如果你的需求是,不但在编译时你需要这个注解,其他时候也需要该注解,比如我想在运行期拦截这个注解 等等！那么请更改注解的生命周期,已符合对应业务。

而如果仅仅只需要编译代码,那么设置为源码期就足够了

那么有了注解了,接下来就是注解处理器

packagecn.kanyun.annotation_processor.taketime;importcom.google.auto.service.AutoService;importcom.sun.source.tree.Tree;importcom.sun.tools.javac.api.JavacTrees;importcom.sun.tools.javac.model.JavacElements;importcom.sun.tools.javac.processing.JavacProcessingEnvironment;importcom.sun.tools.javac.tree.JCTree;importcom.sun.tools.javac.tree.TreeMaker;importcom.sun.tools.javac.util.Context;importcom.sun.tools.javac.util.List;importcom.sun.tools.javac.util.Names;import javax.annotation.processing.*;importjavax.lang.model.SourceVersion;importjavax.lang.model.element.Element;importjavax.lang.model.element.ElementKind;importjavax.lang.model.element.TypeElement;importjavax.lang.model.element.VariableElement;importjavax.lang.model.util.Types;importjavax.tools.Diagnostic;importjava.util.Set;/*** @TakeTime 注解的注解处理器

* @SupportedSourceVersion 表示对应的版本

* @SupportedAnnotationTypes 表示处理哪种类型的注解(这是一个集合, 其值注解的全限定名)

* @AutoService @AutoService(Processor.class) :向javac注册我们这个自定义的注解处理器，

* 这样，在javac编译时，才会调用到我们这个自定义的注解处理器方法。@AutoService这里主要是用来生成

* META-INF/services/javax.annotation.processing.Processor文件的。如果不加上这个注解，那么，你需要自己进行手动配置进行注册

*

* AbstractProcessor是注解处理器的抽象类，我们通过继承AbstractProcessor类然后实现process方法来创建我们自己的注解处理器，

* 所有处理注解的代码放在process方法里面*/@SupportedSourceVersion(value=SourceVersion.RELEASE_8)

@SupportedAnnotationTypes(value= {"cn.kanyun.annotation_processor.taketime.TakeTime"})

@AutoService(Processor.class)public class TakeTimeProcessor extendsAbstractProcessor {/*** Messager接口提供注解处理器用来报告错误消息、警告和其他通知的方式

* 它不是注解处理器开发者的日志工具，而是用来写一些信息给使用此注解器的第三方开发者的

* 注意：我们应该对在处理过程中可能发生的异常进行捕获，通过Messager接口提供的方法通知用户(在官方文档中描述了消息的不同级别。非常重要的是Kind.ERROR)。

* 此外，使用带有Element参数的方法连接到出错的元素，

* 用户可以直接点击错误信息跳到出错源文件的相应行。

* 如果你在process()中抛出一个异常，那么运行注解处理器的JVM将会崩溃(就像其他Java应用一样)，

* 这样用户会从javac中得到一个非常难懂出错信息*/

privateMessager messager;/*** 实现Filer接口的对象，用于创建文件、类和辅助文件。

* 使用Filer你可以创建文件

* Filer中提供了一系列方法,可以用来创建class、java、resources文件

* filer.createClassFile()[创建一个新的类文件，并返回一个对象以允许写入它]

* filer.createResource() [创建一个新的源文件，并返回一个对象以允许写入它]

* filer.createSourceFile() [创建一个用于写入操作的新辅助资源文件，并为它返回一个文件对象]*/

privateFiler filer;/*** 用来处理Element的工具类

* Elements接口的对象，用于操作元素的工具类。*/

privateJavacElements elementUtils;/*** 用来处理TypeMirror的工具类

* 实现Types接口的对象，用于操作类型的工具类。*/

privateTypes typeUtils;/*** 这个依赖需要将${JAVA_HOME}/lib/tools.jar 添加到项目的classpath,IDE默认不加载这个依赖*/

privateJavacTrees trees;/*** 这个依赖需要将${JAVA_HOME}/lib/tools.jar 添加到项目的classpath,IDE默认不加载这个依赖

* TreeMaker创建语法树节点的所有方法，创建时会为创建出来的JCTree设置pos字段，

* 所以必须用上下文相关的TreeMaker对象来创建语法树节点，而不能直接new语法树节点。*/

privateTreeMaker treeMaker;privateNames names;

@Overridepublic synchronized voidinit(ProcessingEnvironment processingEnv) {super.init(processingEnv);

messager=processingEnv.getMessager();

filer=processingEnv.getFiler();

elementUtils=(JavacElements) processingEnv.getElementUtils();

typeUtils=processingEnv.getTypeUtils();this.trees =JavacTrees.instance(processingEnv);

Context context=((JavacProcessingEnvironment) processingEnv).getContext();this.treeMaker =TreeMaker.instance(context);this.names =Names.instance(context);

}/*** 该方法将一轮一轮的遍历源代码

* 处理注解前需要先获取两个重要信息，

* 第一是注解本身的信息，具体来说就是获取注解对象，有了注解对象以后就可以获取注解的值。

* 第二是被注解元素的信息，具体来说就是获取被注解的字段、方法、类等元素的信息

*

*@paramannotations 该方法需要处理的注解类型

*@paramroundEnv 关于一轮遍历中提供给我们调用的信息.

*@return该轮注解是否处理完成 true 下轮或者其他的注解处理器将不会接收到次类型的注解.用处不大.*/@Overridepublic boolean process(Set extends TypeElement>annotations, RoundEnvironment roundEnv) {//roundEnv.getRootElements()会返回工程中所有的Class,在实际应用中需要对各个Class先做过滤以提高效率，避免对每个Class的内容都进行扫描

roundEnv.getRootElements();

messager.printMessage(Diagnostic.Kind.NOTE,"TakeTimeProcessor注解处理器处理中");

TypeElement currentAnnotation= null;//遍历注解集合,也即@SupportedAnnotationTypes中标注的类型

for(TypeElement annotation : annotations) {

messager.printMessage(Diagnostic.Kind.NOTE,"遍历本注解处理器处理的所有注解,当前遍历到的注解是：" +annotation.getSimpleName());

currentAnnotation=annotation;

}//获取所有包含 TakeTime 注解的元素(roundEnv.getElementsAnnotatedWith(TakeTime.class))返回所有被注解了@Factory的元素的列表。你可能已经注意到，我们并没有说“所有被注解了@TakeTime的方法的列表”，因为它真的是返回Element的列表。请记住：Element可以是类、方法、变量等。所以，接下来，我们必须检查这些Element是否是一个方法)

Set extends Element> elementSet = roundEnv.getElementsAnnotatedWith(TakeTime.class);

messager.printMessage(Diagnostic.Kind.NOTE,"TakeTimeProcessor注解处理器处理@TakeTime注解");for(Element element : elementSet) {//获取注解

TakeTime TakeTimeAnnotation = element.getAnnotation(TakeTime.class);//获取注解中配置的值

String tag =TakeTimeAnnotation.tag();

messager.printMessage(Diagnostic.Kind.NOTE, currentAnnotation.getSimpleName()+ "注解上设置的值为：" +tag);//TypeSpec typeSpec = generateCodeByPoet(typeElement, null);//方法名(这里之所以是方法名,是因为这个注解是标注在方法上的)

String methodName =element.getSimpleName().toString();//类名[全限定名]//element.getEnclosingElement()返回封装此元素(非严格意义上)的最里层元素,由于我们在上面判断了element是method类型,所以直接封装method的的就是类了// http://www.169it.com/article/3400309390285698450.html

String className =element.getEnclosingElement().toString();

messager.printMessage(Diagnostic.Kind.NOTE,"当前被标注注解的方法所在的类是：" +className);

messager.printMessage(Diagnostic.Kind.NOTE, currentAnnotation.getSimpleName()+ "当前被标注注解的方法是：" +methodName);//JavaFile javaFile = JavaFile.builder(packageName, typeSpec).build();

enhanceMethodDecl(elementUtils.getTree(element), tag, className + "." +methodName);if (element.getKind() ==ElementKind.FIELD) {//当前element是字段类型

VariableElement variableElement =(VariableElement) element;

messager.printMessage(Diagnostic.Kind.ERROR,"字段不能使用@TakeTime注解", element);

}if (element.getKind() ==ElementKind.CONSTRUCTOR) {//当前element是构造方法类型

}

}return false;

}/*** 方法增强

*

*@paramjcTree

*@parammethodName 方法的全限定名

*@paramtag 标识

*@return

*/

privateJCTree.JCMethodDecl enhanceMethodDecl(JCTree jcTree, String tag, String methodName) {

JCTree.JCMethodDecl jcMethodDecl=(JCTree.JCMethodDecl) jcTree;//生成表达式System.currentTimeMillis()

JCTree.JCExpressionStatement time =treeMaker.Exec(treeMaker.Apply(//参数类型(传入方法的参数的类型) 如果是无参的不能设置为null 使用 List.nil()

List.nil(),

memberAccess("java.lang.System.currentTimeMillis"),//因为不需要传递参数,所以直接设置为List.nil() 不能设置为null

List.nil()//参数集合[集合中每一项的类型需要跟第一个参数对照]//List.of(treeMaker.Literal())

)

);//编译后该方法会存在一个startTime的变量,其值为编译时的时间

JCTree.JCVariableDecl startTime = createVarDef(treeMaker.Modifiers(0), "startTime", memberAccess("java.lang.Long"), treeMaker.Literal(System.currentTimeMillis()));//耗时计算表示式

JCTree.JCExpressionStatement timeoutStatement =treeMaker.Exec(

treeMaker.Apply(

List.of(memberAccess("java.lang.Long"), memberAccess("java.lang.Long")),

memberAccess("java.lang.Math.subtractExact"),

List.of(time.expr, treeMaker.Ident(startTime.name))

)

);// messager.printMessage(Diagnostic.Kind.NOTE, "::::::::::::::::::::");

messager.printMessage(Diagnostic.Kind.NOTE, timeoutStatement.expr.toString());//生成表达式System.out.println()

JCTree.JCExpressionStatement TakeTime =treeMaker.Exec(treeMaker.Apply(//参数类型(传入方法的参数的类型) 如果是无参的不能设置为null 使用 List.nil()

List.of(memberAccess("java.lang.String"), memberAccess("java.lang.String"), memberAccess("java.lang.Long")),//因为这里要传多个参数,所以此处应使用printf,而不是println

memberAccess("java.lang.System.out.printf"),//取到前面定义的startTime的变量//List.of(treeMaker.Ident(startTime.name))//取得结果

List.of(treeMaker.Literal(">>>>>>>>TAG:%s -> 方法%s执行用时：%d<<<<<<

)

);//catch中的代码块

JCTree.JCBlock catchBlock = treeMaker.Block(0, List.of(

treeMaker.Throw(//e 这个字符是catch块中定义的变量

treeMaker.Ident(getNameFromString("e"))

)

));//finally代码块中的代码

JCTree.JCBlock finallyBlock = treeMaker.Block(0, List.of(TakeTime));

List statements =jcMethodDecl.body.getStatements();//遍历方法体中每一行(断句符【分号/大括号】)代码

for(JCTree.JCStatement statement : statements) {

messager.printMessage(Diagnostic.Kind.NOTE,"遍历方法体中的statement：" +statement);

messager.printMessage(Diagnostic.Kind.NOTE,"该statement的类型：" +statement.getKind());if (statement.getKind() ==Tree.Kind.RETURN) {

messager.printMessage(Diagnostic.Kind.NOTE,"该statement是Return语句");break;

}

}//jcMethodDecl.body即为方法体，利用treeMaker的Block方法获取到一个新方法体，将原来的替换掉

jcMethodDecl.body = treeMaker.Block(0, List.of(//定义开始时间,并附上初始值 ,初始值为编译时的时间

startTime,

treeMaker.Exec(//这一步 将startTime变量进行赋值 其值 为(表达式也即运行时时间) startTime = System.currentTimeMillis()

treeMaker.Assign(

treeMaker.Ident(getNameFromString("startTime")),

time.getExpression()

)

),//添加TryCatch

treeMaker.Try(jcMethodDecl.body,

List.of(treeMaker.Catch(createVarDef(treeMaker.Modifiers(0), "e", memberAccess("java.lang.Exception"),null), catchBlock)), finallyBlock)//下面这段是IF代码,是我想在try catch finally后添加return代码(如果有需要的话),结果发现 如果不写下面的代码的话//Javac会进行判断,如果这个方法有返回值的话,那么Javac会自动在try块外定义一个变量,同时找到要上一个return的变量并赋值//然后返回,具体可以查看编译后的字节码的反编译文件,如果该方法没有返回值,那么什么也不做//根据返回值类型,判断是否在方法末尾添加 return 语句 判断返回类型的Kind是否等于TypeKind.VOID//treeMaker.If(treeMaker.Parens(//treeMaker.Binary(//JCTree.Tag.EQ,//treeMaker.Literal(returnType.getKind().toString()),//treeMaker.Literal(TypeKind.VOID.toString()))//),//

// //符合IF判断的Statement//treeMaker.Exec(treeMaker.Literal("返回类型是Void,不需要return")),不符合IF判断的Statement//null//)

)

);returnjcMethodDecl;

}/*** 创建变量语句

*

*@parammodifiers

*@paramname 变量名

*@paramvarType 变量类型

*@paraminit 变量初始化语句

*@return

*/

privateJCTree.JCVariableDecl createVarDef(JCTree.JCModifiers modifiers, String name, JCTree.JCExpression varType, JCTree.JCExpression init) {returntreeMaker.VarDef(

modifiers,//名字

getNameFromString(name),//类型

varType,//初始化语句

init

);

}/*** 根据字符串获取Name，(利用Names的fromString静态方法)

*

*@params

*@return

*/

privatecom.sun.tools.javac.util.Name getNameFromString(String s) {returnnames.fromString(s);

}/*** 创建 域/方法 的多级访问, 方法的标识只能是最后一个

*

*@paramcomponents

*@return

*/

privateJCTree.JCExpression memberAccess(String components) {

String[] componentArray= components.split("\\.");

JCTree.JCExpression expr= treeMaker.Ident(getNameFromString(componentArray[0]));for (int i = 1; i < componentArray.length; i++) {

expr=treeMaker.Select(expr, getNameFromString(componentArray[i]));

}returnexpr;

}

}

这里我自定义的注解处理器,主要操作Javac在编译被注解标注的方法时,在生成字节码时添加自己的逻辑

首先在 方法体的开头 插入一条当前时间的变量 ,并赋值为 System.currentTimeMillis()

然后将整个方法体包括在try块中,添加catch 即finally

catch块中直接定义异常并跑出,finally块中打印用时语句！

之所以添加try catch finally语句,主要是考虑有的方法是在if判断中返回,所以如果在每个return前插入打印用时代码,就十分麻烦

所以直接使用try块包裹方法体来实现!

另外为什么catch块中直接要出异常？因为如果原来的方法体捕获了异常,那么自然不会走自己创建的catch块,如果没有捕获,那么自定义的catch块

会把这个异常原封不动的抛出去,这样并不影响原来的业务了！

直接说并不直观,放两张图片说明问题

这张图是源码

这是编译后的源码,编译后的源码是.class文件，我用IDEA直接打开class文件 就是反编译后的文件

可以看到反编译后的代码,添加了时间变量,和try块代码,需要注意的是,startTime被赋了初始值,这个值其实是这个class被编译的时间,这个初始值也可以设置为其他值，当然必须是Long类型的,或者设置为null,我这里设置这个时间主要是用来测试！建议设置为null

最后看一下 原方法的打印结果：

因为源码中 sleep了3秒中,所以最后直接时间是3001毫秒

同时 mmm 是 注解中的自定义的tag的值,之所以设置这个,是因为如果方法较多时,方便进行查找等！(其实是参照的Android的Logger)

关于注解处理器的文章有很多,我这里只写一些自己认为比较重要的！

1.关于@AutoServier注解 ：如果使用的是maven话,那么直接引入google的 auto-service依赖即可，如果使用的是gradle的话且版本在5(包含)之后

需要添加两条依赖：

//声明注解处理器的注解,用于代替手动编辑resources/META-INF/services的文件

compile group: 'com.google.auto.service', name: 'auto-service', version: '1.0-rc6'

//这行配置也需要添加,gradle升级到5之后,不加此配置,不会生成META-INF/services/javax.annotation.processing.Processor文件

annotationProcessor group: 'com.google.auto.service', name: 'auto-service', version: '1.0-rc6'

如果当注解处理器打完包后,被其他项目(gradle)引用,也要 使用 compile / annotationProcessor 来引入两次

2.理解几个常见的类 ：

声明变量

JCTree.JCVariableDecl

定义变量

long a = 1

JCTree.JCExpressionStatement

生成表达式

a = System.currentTimeMillis()

JCTree.JCBlock

代码块(主要是用来放其他代码块,或者JCExpressionStatement的)