java AbstractProcessor 编译时注解（API）

青旅半醒 2023-10-08 17:07 9阅读 0赞

#### 文章目录 ####

*  写在前面
 *   *  1、编译时注解原理
     *  2、AbstractProcessor 解析
     *   *  2.1、RoundEnvironment
         *  2.2、获取Messager、JavacTrees、TreeMaker、Names、elementUtils
         *  2.3、JCTree
         *   *  2.3.1、pos和defs
             *  2.3.2、JCTree访问者模式
         *  2.4、TreeMaker
     *  3、实例一：@NoArgsConstructor 添加无参构造函数
     *   *  3.1、pom
         *  3.2、代码
     *  4、实例二：@AllArgsConstructor 添加全参构造函数
     *   *  4.1、pom
         *  4.2、代码

## 写在前面 ##

接上一篇文章：[java AbstractProcessor 编译时注解（入手体验）][java AbstractProcessor]

### 1、编译时注解原理 ###

在java文件编译成class文件之前，对java文件进行操作，生成代码。  
AbstractProcessor 完成的就是对java文件进行操作的相关功能。

相关知识点：

1、java文件操作相关的两个类： JCTree 树节点、TreeMaker 树节点构建器  
2、**JCTree 的一个子类就是java语法中的一个节点**，类、方法、字段等这些都被封装成了一个JCTree子类。  
3、**TreeMaker 里的一个方法用于构建JCTree某个子类**，例：treeMaker.MethodDef(…)返回值是JCTree的子类JCMethodDecl（方法节点）

### 2、AbstractProcessor 解析 ###

一个编译时注解，最后对java文件进行的操作，都在 AbstractProcessor 子类中编写。  
![在这里插入图片描述][95f995206d0e4fc48b560fc17507199e.png]

1.  @SupportedAnnotationTypes(“cc.HelloWorld”) ，“cc.HelloWorld” 是**HelloWorld注解的类全名**。
2.  @SupportedSourceVersion(SourceVersion.RELEASE\_7) ，annotation支持版本,**向前兼容到JDK7**。
3.  @AutoService(Processor.class)，让AbstractProcessor子类**被编译器发现**。
4.  annotations 传进来的**注解列表**。
5.  roundEnv 环境，可以从它**获取被注解标记的元素**，然后获取元素的JCTree对象。
6.  process 方法返回值，涉及到编译器的处理逻辑，**返回true表示已经处理，返回false表示未被处理**。

> 注意AbstractProcessor每一次有修改，就要重新编译该类。或者有修改就删除target，让编译器重新生成class文件

#### 2.1、RoundEnvironment ####

process 方法的第二个参数RoundEnvironment roundEnv，可以从里面获取java文件的树结构，并往里面加入代码。  
RoundEnvironment 的方法：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>errorRaised()</td> 
   <td>如果在前一轮处理中引发错误，则返回true ; 否则返回false 。</td> 
  </tr> 
  <tr> 
   <td>processingOver()</td> 
   <td>如果此轮生成的类型不受后续轮注释处理的影响，则返回true ; 否则返回false 。</td> 
  </tr> 
  <tr> 
   <td>getRootElements()</td> 
   <td>返回前一轮生成的注释处理的root elements 。</td> 
  </tr> 
  <tr> 
   <td>getElementsAnnotatedWith()</td> 
   <td>返回被某个注解标记的元素。</td> 
  </tr> 
  <tr> 
   <td>getElementsAnnotatedWithAny()</td> 
   <td>返回多个注解标记的元素。</td> 
  </tr> 
 </tbody> 
</table>

#### 2.2、获取Messager、JavacTrees、TreeMaker、Names、elementUtils ####

这些对象中，JavacTrees和TreeMaker是一定会用到的

@SupportedAnnotationTypes("这里填注解类的全名")
    @SupportedSourceVersion(SourceVersion.RELEASE_8)
    @AutoService(Processor.class)
    public class MyProcessor extends AbstractProcessor {
        
        Messager messager;                 // 用于在编译器打印消息的组件
        Names names;                       // 用于创建标识符的对象
        JavacTrees trees;                  // 语法树
        JavacElements elementUtils;        // trees 和 elementUtils都可以获取 元素的JCTree对象
        TreeMaker treeMaker;               // 用来构造语法树节点
    
        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
        
            super.init(processingEnv);
            Context context = ((JavacProcessingEnvironment) this.processingEnv).getContext();
            this.elementUtils = (JavacElements) this.processingEnv.getElementUtils();
            this.messager = this.processingEnv.getMessager();
            this.names = Names.instance(this.context);
            this.trees = JavacTrees.instance(this.processingEnv);
            this.treeMaker = TreeMaker.instance(this.context);
        }
        
        @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        
    		...
            return true;
        }

> 这里有个坑，获取Messager、JavacTrees、TreeMaker这些对象只能在init()方法里面或者init()方法执行之后，否则获取不到这些对象，如下错误示例。  
> ![在这里插入图片描述][89d2af0faf8b4d95be672f04b89babfa.png]

#### 2.3、JCTree ####

**JCTree 的一个子类就是java语法中的一个节点**，类、方法、字段等这些都被封装成了一个JCTree子类。  
JCTree 从JavacTrees中获取，如下例：

public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        
            Set<? extends Element> elementSet = roundEnv.getElementsAnnotatedWith(HelloWorld.class);
    
    		elementSet.forEach(element -> {
        
                //获取元素的JCTree对象
                JCTree jcTree = trees.getTree(element);               // JCTree也可以使用elementUtils获取： JCTree jcTree = elementUtils.getTree(element);
                ...
                });
            return true;
        }

JCTree 是语法树的基类，包含子类：

<table> 
 <thead> 
  <tr> 
   <th>父类</th> 
   <th>子类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JCTree</td> 
   <td>声明节点 JCStatement、方法定义节点 JCMethodDecl、访问标志节点 JCModifiers、表达式节点 JCExpression</td> 
  </tr> 
  <tr> 
   <td>JCStatement 声明节点</td> 
   <td>语块JCBlock、返回语句JCReturn、类定义JCClassDecl、 字段定义JCVariableDecl</td> 
  </tr> 
  <tr> 
   <td>JCExpression 表达式节点</td> 
   <td>赋值语句语JCAssign、变量，类型，关键字JCIdent</td> 
  </tr> 
  <tr> 
   <td>JCMethodDecl 方法节点</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>JCModifiers 访问标识节点</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

![在这里插入图片描述][48a1f4e3b21a416eb2110eeac21a914d.png]

##### 2.3.1、pos和defs #####

jcTree.pos 用于指明当前节点在语法树中的位置，treeMaker也有这个字段。  
jcTree.defs 类定义的详细语句，包括字段，方法定义等，treeMaker也有这个字段。

##### 2.3.2、JCTree访问者模式 #####

> 如果你对访问者模式没有了解，建议先阅读这篇文章：[访问者模式一篇就够了][Link 1]

JCTree jcTree = trees.getTree(element); 
    // JCTree利用的是访问者模式，将数据与数据的处理进行解耦，TreeTranslator是访问者，这里可以重写访问类时的逻辑
    jcTree.accept(new TreeTranslator(){
        ...});

#### 2.4、TreeMaker ####

TreeMaker 里的一个方法用于构建JCTree某个子类，例：treeMaker.MethodDef(…)返回值是JCTree的子类JCMethodDecl（方法节点）。

参考官方文档：[TreeMaker文档][TreeMaker]

TreeMaker创建各种节点的方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Modifiers()</td> 
   <td>创建访问标志</td> 
  </tr> 
  <tr> 
   <td>ClassDef()</td> 
   <td>类定义</td> 
  </tr> 
  <tr> 
   <td>MethodDef()</td> 
   <td>方法定义</td> 
  </tr> 
  <tr> 
   <td>VarDef()</td> 
   <td>创建字段/变量</td> 
  </tr> 
  <tr> 
   <td>Ident()</td> 
   <td>创建标识符</td> 
  </tr> 
  <tr> 
   <td>Return()</td> 
   <td>返回语句</td> 
  </tr> 
  <tr> 
   <td>Select()</td> 
   <td>创建域访问/方法访问</td> 
  </tr> 
  <tr> 
   <td>NewClass()</td> 
   <td>创建new语句</td> 
  </tr> 
  <tr> 
   <td>Apply()</td> 
   <td>创建方法调用</td> 
  </tr> 
  <tr> 
   <td>Assign()</td> 
   <td>创建赋值语句</td> 
  </tr> 
  <tr> 
   <td>Exec()</td> 
   <td>创建可执行语句</td> 
  </tr> 
  <tr> 
   <td>Block()</td> 
   <td>创建组合语句</td> 
  </tr> 
 </tbody> 
</table>

示例:

// public访问修饰符
    JCTree.JCModifiers publicDot = treeMaker.Modifiers(Flags.PUBLIC);
    // void关键字
    JCTree.JCPrimitiveTypeTree voidDot = treeMaker.TypeIdent(TypeTag.VOID);
    // 空语句
    JCTree.JCBlock emptyDot = treeMaker.Block(0, List.nil());
    // 一个无参构造方法
    JCTree.JCMethodDecl noArgsMethod = treeMaker.MethodDef(
                        publicDot,
                        names.fromString("<init>"),
                        voidDot ,
                        List.nil(),
                        List.nil(),
                        List.nil(),
                        emptyDot,
                        null);
    
    
    
    // this关键字
    JCTree.JCIdent thisDot = treeMaker.Ident(names.fromString("this"));
    // userPassword                           (Name类型可以是方法名、字段名、变量名、类名)
    Name userPasswordName = names.fromString("userPassword");
    // this.userPassword                      (访问当前方法中的字段userPassword)
    JCTree.JCFieldAccess thisUserPassword = treeMaker.Select(thisDot , userPasswordName);
    // userPassword 变量
    JCTree.JCIdent userPassword = treeMaker.Ident(userPasswordName);
    // this.userPassword = userPassword       (treeMaker.Apply()以及treeMaker.Assign()需要外面包一层treeMaker.Exec())
    treeMaker.Exec(treeMaker.Assign(thisUserPassword, userPassword));

### 3、实例一：@NoArgsConstructor 添加无参构造函数 ###

本实例未使用JCTree访问者模式，直接添加一个无参构造函数到jcTree.defs中

新建项目a（使用注解）、b（写编译时注解功能）

#### 3.1、pom ####

项目b的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
             
        <artifactId>b</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
        <properties>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
    
        <dependencies>
    
            
            <dependency>
                <groupId>com.google.auto.service</groupId>
                <artifactId>auto-service</artifactId>
                <version>1.0-rc5</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>
            <dependency>
                <groupId>commons-validator</groupId>
                <artifactId>commons-validator</artifactId>
                <version>1.3.1</version>
            </dependency>
    
        </dependencies>
    
    </project>

项目a的poml.xml（引入项目b）

#### 3.2、代码 ####

@NoArgsConstructor

package cc;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface NoArgsConstructor {
        
    }

NoArgsConstructorProcessor.java

项目a中使用@NoArgsConstructor

import cc.NoArgsConstructor;
    
    @NoArgsConstructor
    public class Test {
        
    
        public Test(String s){
        }
        
        public static void main(String[] args) {
        }
    }

Test编译后的class  
![在这里插入图片描述][5e572c93749c4b2da30d75eab3772223.png]

### 4、实例二：@AllArgsConstructor 添加全参构造函数 ###

本实例使用JCTree访问者模式。

新建项目a（使用注解）、b（写编译时注解功能）

#### 4.1、pom ####

同 3.1、pom

#### 4.2、代码 ####

@AllArgsConstructor

AllArgsConstructorProcessor.java

package cc;
    
    import com.google.auto.service.AutoService;
    import com.sun.tools.javac.api.JavacTrees;
    import com.sun.tools.javac.code.Flags;
    import com.sun.tools.javac.code.TypeTag;
    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.tree.TreeTranslator;
    import com.sun.tools.javac.util.Context;
    import com.sun.tools.javac.util.List;
    import com.sun.tools.javac.util.ListBuffer;
    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.Modifier;
    import javax.lang.model.element.TypeElement;
    import java.util.Set;
    
    @SupportedAnnotationTypes("cc.AllArgsConstructor")
    @SupportedSourceVersion(SourceVersion.RELEASE_8)
    @AutoService(Processor.class)
    public class AllArgsConstructorProcessor extends AbstractProcessor {
        
        JavacTrees trees;
        TreeMaker treeMaker;
        Names names;
    
        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
        
            super.init(processingEnv);
            Context context = ((JavacProcessingEnvironment) this.processingEnv).getContext();
            this.trees = JavacTrees.instance(this.processingEnv);
            this.treeMaker = TreeMaker.instance(context);
            this.names = Names.instance(context);
        }
    
        /**
         * 字段的语法树节点的集合
         */
        private List<JCTree.JCVariableDecl> fieldJcVariables;
    
    
        @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        
            Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(AllArgsConstructor.class);
            set.forEach(element -> {
        
                JCTree jcTree = trees.getTree(element);
                jcTree.accept(new TreeTranslator() {
        
    
                    @Override
                    public void visitClassDef(JCTree.JCClassDecl jcClass) {
        
                        before(jcClass);
    
                        //添加全参构造方法
                        jcClass.defs = jcClass.defs.append(
                                    createAllArgsConstructor()
                        );
                        after();
                    }
                });
            });
    
            return true;
        }
    
        /**
         * 判断是否是合法的字段
         *
         * @param jcTree 语法树节点
         * @return 是否是合法字段
         */
        private static boolean isValidField(JCTree jcTree) {
        
            if (jcTree.getKind().equals(JCTree.Kind.VARIABLE)) {
        
                JCTree.JCVariableDecl jcVariable = (JCTree.JCVariableDecl) jcTree;
    
                Set<Modifier> flagSets = jcVariable.mods.getFlags();
                return (!flagSets.contains(Modifier.STATIC)
                        && !flagSets.contains(Modifier.FINAL));
            }
    
            return false;
        }
    
        /**
         * 进行一些初始化工作
         *
         * @param jcClass 类的语法树节点
         */
        private void before(JCTree.JCClassDecl jcClass) {
        
            ListBuffer<JCTree.JCVariableDecl> jcVariables = new ListBuffer<>();
    
            //遍历jcClass的所有内部节点，可能是字段，方法等等
            for (JCTree jcTree : jcClass.defs) {
        
                //找出所有set方法节点，并添加
                if (isValidField(jcTree)) {
        
                    //注意这个com.sun.tools.javac.util.List的用法，不支持链式操作，更改后必须赋值
                    jcVariables.append((JCTree.JCVariableDecl) jcTree);
                }
            }
            this.fieldJcVariables = jcVariables.toList();
        }
    
        /**
         * 清理
         */
        private void after() {
        
            this.fieldJcVariables = null;
        }
    
        /**
         * 创建全参数构造方法
         *
         * @return 全参构造方法语法树节点
         */
        private JCTree.JCMethodDecl createAllArgsConstructor() {
        
            ListBuffer<JCTree.JCStatement> jcStatements = new ListBuffer<>();
            for (JCTree.JCVariableDecl jcVariable : fieldJcVariables) {
        
                Name name = names.fromString(jcVariable.name.toString());
                JCTree.JCIdent thisIdent = treeMaker.Ident(names.fromString("this"));
    
                JCTree.JCFieldAccess select = treeMaker.Select(thisIdent, name);
                JCTree.JCIdent ident = treeMaker.Ident(names.fromString(jcVariable.name.toString()));
    
                //添加构造方法的赋值语句 " this.xxx = xxx; "
                jcStatements.append(
                        treeMaker.Exec(treeMaker.Assign(select, ident))
                );
            }
    
            return treeMaker.MethodDef(
                    treeMaker.Modifiers(Flags.PUBLIC),
                    names.fromString("<init>"),
                    treeMaker.TypeIdent(TypeTag.VOID),
                    List.nil(),
                    cloneJCVariablesAsParams(treeMaker, fieldJcVariables),
                    List.nil(),
                    treeMaker.Block(0 , jcStatements.toList()),
                    null
            );
        }
    
        /**
         * 克隆一个字段的语法树节点集合，作为方法的参数列表
         *
         * @param treeMaker            语法树节点构造器
         * @param prototypeJCVariables 字段的语法树节点集合
         * @return 方法参数的语法树节点集合
         */
        static List<JCTree.JCVariableDecl> cloneJCVariablesAsParams(TreeMaker treeMaker, List<JCTree.JCVariableDecl> prototypeJCVariables) {
        
            ListBuffer<JCTree.JCVariableDecl> jcVariables = new ListBuffer<>();
            for (JCTree.JCVariableDecl jcVariable : prototypeJCVariables) {
        
                jcVariables.append(cloneJCVariableAsParam(treeMaker, jcVariable));
            }
            return jcVariables.toList();
        }
    
        /**
         * 克隆一个字段的语法树节点，该节点作为方法的参数
         * 具有位置信息的语法树节点是不能复用的！
         *
         * @param treeMaker           语法树节点构造器
         * @param prototypeJCVariable 字段的语法树节点
         * @return 方法参数的语法树节点
         */
        static JCTree.JCVariableDecl cloneJCVariableAsParam(TreeMaker treeMaker, JCTree.JCVariableDecl prototypeJCVariable) {
        
            return treeMaker.VarDef(
                    treeMaker.Modifiers(Flags.PARAMETER), //访问标志。极其坑爹！！！
                    prototypeJCVariable.name, //名字
                    prototypeJCVariable.vartype, //类型
                    null //初始化语句
            );
        }
    }

项目a中使用@AllArgsConstructor

import cc.AllArgsConstructor;
    
    @AllArgsConstructor
    public class Test {
        
        private String a;
        private String b;
    
        public static void main(String[] args) {
        }
    }

编译后的class文件  
![在这里插入图片描述][2bbc84a00dbc417e855c01a7e8a218c8.png]

[java AbstractProcessor]: https://blog.csdn.net/a__int__/article/details/127447945
[95f995206d0e4fc48b560fc17507199e.png]: https://img-blog.csdnimg.cn/95f995206d0e4fc48b560fc17507199e.png
[89d2af0faf8b4d95be672f04b89babfa.png]: https://img-blog.csdnimg.cn/89d2af0faf8b4d95be672f04b89babfa.png
[48a1f4e3b21a416eb2110eeac21a914d.png]: https://img-blog.csdnimg.cn/48a1f4e3b21a416eb2110eeac21a914d.png
[Link 1]: https://www.jianshu.com/p/1f1049d0a0f4
[TreeMaker]: http://www.docjar.com/docs/api/com/sun/tools/javac/tree/TreeMaker.html
[5e572c93749c4b2da30d75eab3772223.png]: https://img-blog.csdnimg.cn/5e572c93749c4b2da30d75eab3772223.png
[2bbc84a00dbc417e855c01a7e8a218c8.png]: https://img-blog.csdnimg.cn/2bbc84a00dbc417e855c01a7e8a218c8.png