java自定义编译时注解器

一、注解器

java 注解编译处理器，主要作用是针对特定的注解进行相应的处理。根据个人观察目前主要多用于代码生成、代码审查。在安卓开发中，常用的Butterknife、Dagger2、Room等以及一些组件化的框架都都会看到编译注解处理器的身影。而在java后端的开发中 Lombok 也是有使用到边缘处理器的。

关于注解的定义及分类的大概信息如下图，图片来源于 https://blog.csdn.net/asd54090/article/details/80920667 ， 感谢前辈大佬的整理。

图1

二、认识AbstractProcessor

注解处理器（Annotation Processor） 是javac 的一个工具，主要是在编译时扫描和处理由注解。那么我们要处理特定的注解，自然是上不了注解处理器，想要自定义注解处理器处理特定的逻辑和代码，那么就应该继承 AbstractProcessor 这个抽象类，并实现 process方法。

AbstractProcessor 类的主要几个方法如下：

  • init(ProcessingEnvironment env) ：由注解工具调用，并传入 ProcessingEnvironment 参数，ProcessingEnvironment 提供很多工具类Messager、Types、Elements 、Filer 等等。

  • process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) ：每个处理器的核心处理业务都在这里得到执行，可以实现代码扫描、评估、注释代码处理，生成java文件。通过参数RoundEnvironment的 getElementsAnnotatedWith 可以获取到特定注解的元素。

  • getSupportedSourceVersion()：主要用来指定处理器支持处理的Java版本，通常使用SourceVersion.latestSupported() 作为返回值。当然如果自定义注解类使用了@SupportedSourceVersion 注解，可以不用重写此方法。

    注意：如果使用@SupportedSourceVersion 注解，需要考虑，这个注解是 java 6 才引入的

  • getSupportedAnnotationTypes() : 主要是用来设置当前注解处理器支持处理的注解，如果不指定需要处理的注解，则 process 方法将不会得到执行。该方法返回的是 Set<String> 集合，包含支持注解的合法全称。

    注意：该方法也可以使用@SupportedAnnotationTypes 注解来代替。

三、自定义 Annotation Processor

实现自定义注解大概分为以下这几个步骤:

step1、定义注解；

step2、继承 AbstractProcessor 类并实现抽象方法 process 和重新上面介绍到的另外几个方法;

step3、编写关键的业务代码逻辑，主要在逻辑应写在 process 方法中；比如解析语法树，编辑修改、增加语法树等等

（关于语法树，本次不做记录和解释，后面再新的篇幅另做介绍。）

新建工程，maven 依赖如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependencies>
   <dependency>
     <groupId>com.google.auto.service</groupId>
     <artifactId>auto-service</artifactId>
     <version>1.0-rc2</version>
   </dependency>
   <dependency>
     <groupId>com.sun</groupId>
     <artifactId>tools</artifactId>
     <version>1.8</version>
     <scope>system</scope>
     <systemPath>${java.home}/../lib/tools.jar</systemPath>
   </dependency>
 </dependencies>
  • AutoService 会自动在META-INF文件夹下生成Processor配置信息文件，该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。基于这样一个约定就能很好的找到服务接口的实现类，而不需要再代码里制定，方便快捷。

如果不依赖 auto-service 时，则需要在 META-INF\services 文件夹下手动创建 javax.annotation.processing.Processor 文件。并且保存自定义注解器的包路径，如：com.godc.XAnnotionProcessor

  • tools 依赖包是jdk 自带的工具包，语法树相关的都会用到该依赖。比如：JCTree、TreeMaker

首先定义一个注解，比如一个方法注解，在注解的方法中添加日志打印

1
2
3
4
5
6
7
8
9
10
package com.godc.annotation;

import java.lang.annotation.*;

@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface Plog {

}

自定义处理器类如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package com.godc;

import com.godc.annotation.Inject;
import com.godc.annotation.InjectParams;
import com.godc.annotation.Plog;
import com.godc.annotation.Service;
import com.google.auto.service.AutoService;
import com.sun.source.util.Trees;
import com.sun.tools.javac.model.JavacElements;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Names;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * @ClassName MyAnnotionProcessor
 * @Description TODO
 * @Author chenxx
 * @Date 2021/2/18 17:28
 * @Version 1.0
 */
@AutoService(Processor.class)
public class MyAnnotionProcessor extends AbstractProcessor {


    Trees trees;
    Names names;
    TreeMaker treeMaker;
    JavacElements javacElements;
    Messager messager;

    // 设置当前注解处理器需要处理的注解
    private static final List<Class<? extends Annotation>> ANNOTATIONS = Arrays.asList(
            Inject.class
    );


    /**
     * init 方法由注解工具的构造方法调用，并传入 ProcessingEnvironment  参数
     * 该参数提供了很多工具类，比如 Elements， Filer， Messager， Types，TreMaker，Names
     * @param processingEnv
     */
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        Context context = ((JavacProcessingEnvironment)processingEnv).getContext();
        messager = processingEnv.getMessager();
        trees = Trees.instance(processingEnv);
        names = Names.instance(context);
        javacElements = ((JavacProcessingEnvironment) processingEnv).getElementUtils();
        treeMaker = TreeMaker.instance(context);
    }


    /**
     * 这个方法虽我们也是需要实现。
     * 因为该方法的作用是明确指定我们要处理哪些注解的，
     * 所以你要在这里指明，你需要处理的注解的全称。
     *
     * 返回值是一个字符串的集合，包含着本处理器想要处理的注解类型的合法全称。
     */
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> supportAnnotationTypes = new LinkedHashSet<>();
        for (Class<? extends Annotation> annotation : ANNOTATIONS){
            supportAnnotationTypes.add(annotation.getCanonicalName());
        }
        return supportAnnotationTypes;
    }

    /**
     * 主要用来指定处理器支持处理的Java版本，通常使用 SourceVersion.latestSupported()`
     * @return
     */
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }


    /**
     * 每个处理器的核心处理业务都在这里得到执行，可以实现代码扫描、评估、注释代码处理，生成java文件。
     * 通过参数`RoundEnvironment`的 `getElementsAnnotatedWith` 可以获取到特定注解的元素。
     * @param annotations
     * @param roundEnv
     * @return
     */
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Set<? extends Element> elementSet = roundEnv.getElementsAnnotatedWith(Inject.class);
        System.out.println("====================");
        for (Element element : elementSet){
            JCTree.JCMethodDecl jcMethodDecl = (JCTree.JCMethodDecl) javacElements.getTree(element);

            treeMaker.pos = jcMethodDecl.pos;
            jcMethodDecl.body = treeMaker.Block(1, com.sun.tools.javac.util.List.of(
                    treeMaker.Exec(
                            treeMaker.Apply(com.sun.tools.javac.util.List.nil(),treeMaker.Select(
                                    treeMaker.Select(
                                            treeMaker.Ident(
                                                    javacElements.getName("System")
                                            ),
                                            javacElements.getName("out")
                                    ),
                                    javacElements.getName("println")
                            ),com.sun.tools.javac.util.List.of(treeMaker.Literal("Hello, world!!!")))
                    ),
                    jcMethodDecl.body
            ));

        }
        System.out.println("====================");
        return false;
    }
}

编写测试方法，并使用注解，编译项目就会得到如下效果

图2

四、调试注解器

在 IDEA中调试编译注解器还是挺方便的，IDEA作为客户端，JVM作为服务端。主要三个步骤：

  1. 在注解器中打断点
  2. 在IDEA （Edit Configurations）中配置远程调试 （如下图3）
  3. 在 terminal 控制台输入 mvnDebug clean package，打开maven 远程调试服务监听 8000 端口了
  4. 点击debug 按钮 启动远程调试

图3

在此次的测试中，项目结构如下图：

mprocessor 为注解器模块，存放注解、注解器的实现，代码生成

testprocessor 为测试模块，依赖 注解器模块 做测试

图4

资源来源：

https://blog.csdn.net/asd54090/article/details/80920667

https://docs.oracle.com/javase/7/docs/api/javax/annotation/processing/AbstractProcessor.html

https://blog.csdn.net/dap769815768/article/details/90448451

https://www.jianshu.com/p/68fcbc154c2f

https://www.jianshu.com/p/d0dd91c7c560

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码