Java Pluginable Annotation processing

深藏阁楼爱情的钟 2022-10-29 06:28 107阅读 0赞

> 本文是《深入理解JVM理解字节码》读后笔记，案例和图均来自书中

# 什么是插件化注解处理器 #

`插件化注解处理器(Pluginable Annotation processing)`又称`编译时注解`.  
我们先了解Java编译流程：

`javac`属于编译前端(生成非机器码的中间代码)，编译后端(机器码)在`JIT`触发.我们只需要关心编译前端即可。  
`javac`经过`parse`和`enter`(语法分析，词法分析)会生成一个`抽象语法树(AST)`,然后调用注解处理器，注解处理器可以在这个阶段使用对应语法修改`语法树`结构。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]

## 抽象语法树 ##

我们看下如下代码  
`int k = i+j;`  
在生成抽象语法后变成如下结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]  
抽象语法树可以表示所有的表达式，而每个表达式节点都是用`JCTree`的自类表示。

部分`JCTree`继承图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]

注解处理器关键类：

1: `Ctree`: 表示抽象语法树的节点。  
2: `Names` 用于生成`Name`对象  
3: `Name` 内部存储一个字符串，用于存储`this`,`super`等字符串。比如`int k`的`k`就是`Name`

4:`JavacTrees` 可以用于获取类对象的抽象语法树

5: `TreeMaker` 用于添加和修改抽象语法树

--------------------

# 用注解处理器生成`Get`和`Set`方法 #

public class User {
        
        private int id;
    }

我们的对象有一个私有属性`int id`,我们利用注解处理器添加它的`get`和`set`函数.

首先声明一个注解，标识哪个对象需要生成`Get`和`Set`

//标识只能在类中
    @Target({
        ElementType.TYPE})
    //因为注解处理器只在编译期，所以标识这个注解只在源码阶段,
    @Retention(RetentionPolicy.SOURCE)
    public @interface MyDataBean {
        
    }

编写注解处理器

最后我们复写`AbstractProcessor`的`process`函数进行处理。

//注解处理器处理那种注解
    @SupportedAnnotationTypes("MyDataBean")
    //标识注解处理器所支持的源代码版本
    @SupportedSourceVersion(SourceVersion.RELEASE_8)
    public class MyDataAnnotationProcessor extends AbstractProcessor {
        
    
        //环境上下文
        private Context context;
        //AST  Abstract  Syntax Tree
        private JavacTrees javacTrees;
        //可以用于创建一个name
        private Names names;
        //可用于生成
        private TreeMaker treeMaker;
    
    	//注解处理器初始化回调
        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
        
          //...
        }
    
    	  @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        
    
    		//获取被MyDataBean注释的类集合
    		//Element对象可以用于标识java的 包(packageElement)，类对象(TypeElement)，方法(ExecutableElement)。
            Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(MyDataBean.class);
    		
            for (Element element : set) {
        
            	//类element转化为抽象语法树
                JCTree tree = javacTrees.getTree(element);
    			//tree.accept函数遍历子树
    			//TreeTranslator可以选择遍历遍历：
    			// 类类型的JCTree.JCClassDecl 的visitClassDef函数
    			// 方法类型的visitMethodDef的visitMethodDef函数
                tree.accept(new TreeTranslator() {
        
                
                    @Override
                    public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
        					
                    	//JCClassDecl的defs标识所有子树 
                        jcClassDecl.defs.stream().filter(it ->
                                //it也是JCTree类型，getKind可以获取Kind类
                                //Kind类可以获取是哪一种类型，比如是变量类型，方法类型
                                //这里我们只要变量类型
                                it.getKind()
                                        .equals(Tree.Kind.VARIABLE)
                        ).map(it -> (JCTree.JCVariableDecl) it).forEach(it -> {
        
                        	//prepend可以添加一个抽象语法树，然后返回覆盖原始的defs即可
                        	//genGetterMethod genSetterMethod 两个自定义函数，返回一个新的抽象语法书节点
                            jcClassDecl.defs = jcClassDecl.defs.prepend(genGetterMethod(it));
                            
                            jcClassDecl.defs = jcClassDecl.defs.prepend(genSetterMethod(it));
    
    
                        });
                        super.visitClassDef(jcClassDecl);
    
                    }
                });
    
            }
            return true;
        }
    	
    }

class MyDataAnnotationProcessor{
        
    
    
    	//生成GetXXX函数的的Ctree
        private JCTree.JCMethodDecl genGetterMethod(JCTree.JCVariableDecl jcVariableDecl) {
        
    
            JCTree.JCReturn returnStatement =
                    treeMaker.Return(treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.getName()));
    
            ListBuffer<JCTree.JCStatement> jcStatements = new ListBuffer<JCTree.JCStatement>()
                    .append(returnStatement);
    
            JCTree.JCModifiers modifiers = treeMaker.Modifiers(Flags.PUBLIC);
    
            //方法名字 getXX
            Name getMethodName = getMethodName(jcVariableDecl.getName());
            //返回值类型
            JCTree.JCExpression returnMethodType = jcVariableDecl.vartype;
            //生成方法体
            JCTree.JCBlock body = treeMaker.Block(0, jcStatements.toList());
            //泛型参数列表
            List<JCTree.JCTypeParameter> methodGenericParamList = List.nil();
    
            //参数列表
            List<JCTree.JCVariableDecl> paramList = List.nil();
            //抛出异常
            List<JCTree.JCExpression> thorwnCauseList = List.nil();
    
            System.out.println("开始调用最后的定义");
    
            return treeMaker.MethodDef(
                    modifiers,//方法修饰符
                    getMethodName,//方法名字
                    returnMethodType,//返回值类型
                    methodGenericParamList,
                    paramList,
                    thorwnCauseList,
                    body,
                    null
            );
    
        }
    
        private JCTree.JCMethodDecl genSetterMethod(JCTree.JCVariableDecl jcVariableDecl) {
        
    
    
            JCTree.JCExpressionStatement statement =
                    treeMaker.Exec(
                            treeMaker.Assign(
                                    //左侧表达式 this.xxx
                                    treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.name),
                                    //右侧表达式 传入的变量
                                    treeMaker.Ident(jcVariableDecl.name)
                            ));
    
    
            ListBuffer<JCTree.JCStatement> jcStatements = new ListBuffer<JCTree.JCStatement>()
                    .append(statement);
    
    
            JCTree.JCVariableDecl param = treeMaker.VarDef(
                    treeMaker.Modifiers(Flags.PARAMETER, List.nil()),
                    jcVariableDecl.name,
                    jcVariableDecl.vartype,//变量类型
                    null);//初始化值 这里不需要
            ;
    
            JCTree.JCModifiers modifiers = treeMaker.Modifiers(Flags.PUBLIC);
    
            //方法名字 getXX
            Name getMethodName = setMethodName(jcVariableDecl.getName());
            //返回值类型
            JCTree.JCExpression returnMethodType = treeMaker.Type(new Type.JCVoidType());
    
            //生成方法体
            JCTree.JCBlock body = treeMaker.Block(0, jcStatements.toList());
            //泛型参数列表
            List<JCTree.JCTypeParameter> methodGenericParamList = List.nil();
            System.out.println("methodGenericParamList");
            //参数列表
            List<JCTree.JCVariableDecl> paramList = List.of(param);
            //抛出异常
            List<JCTree.JCExpression> thorwnCauseList = List.nil();
    
            System.out.println("开始调用最后的定义");
    
            return treeMaker.MethodDef(
                    modifiers,//方法修饰符
                    getMethodName,//方法名字
                    returnMethodType,//返回值类型
                    methodGenericParamList,//方法的泛型类别
                    paramList,//参数列表
                    thorwnCauseList,//异常声明
                    body,//方法体
                    null
            );
        }
    
    	//获取GetXXX方法的对应Name对象，传入的为变量的Name
        private Name getMethodName(Name name) {
        
            String fieldName = name.toString();
            return names.fromString("get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length()));
        }
    
    	//获取SetXXX对应的Name对象，传入的为变量的Name
        private Name setMethodName(Name name) {
        
            String fieldName = name.toString();
            return names.fromString("set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length()));
        }
    }

上面便完成了我们的注解处理。我们看下如何使用的问题：

## 打包成Jar使用注解处理器 ##

在打包的时候添加如下额外`元信息`：

在 `META-INF/services` 目录文件夹下创建`javax.annotation.processing.Processor` 文件.

在 `javax.annotation.processing.Processor` 文件写入注解处理器的全称，包括包路径.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]

编译目录：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]

最后运行如下命令即可  
`javac -classpath .:./JavaKotlinDemo-1.0-SNAPSHOT.jar -d out User.java`

声明元信息比较麻烦可以考虑使用`auto-service`库.

最后一个问题如果我们常规的使用`gradle`， `maven`直接将注解处理器依赖会增大包提，所以`gradle` 提供`annotationProcessor`和`kapt`等依赖方式。

## 声明式使用注解处理器 ##

1.  首先编译我们的注解处理器和注解得到`class`  
    ![在这里插入图片描述][20210209131121552.png]
2.  手动编译剩下的文件

![3.][]  
`javac -cp . -d out -processor MyDataAnnotatiorocessor User.java`

`-processor`用于声明注解处理器的类

最后我们在out目录输出得到`User.class`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221024/9b236af5693c4e8b8b3895a8028fede7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]: /images/20221024/d6aaa9fe4f8f472dbfbe34a0348ff40e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]: /images/20221024/0a8be9d11e2d4d28beb64338e0f1f661.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]: /images/20221024/0cc4fe32795c42ebac3f577db4ef8daa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]: /images/20221024/12cfdcc5079e456395d887ea14939a17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]: /images/20221024/0ccb0986c68c46daa8548129a785efea.png
[20210209131121552.png]: /images/20221024/7fdf7d1f63154083b3c8fde5ab641075.png
[3.]: /images/20221024/1c84b14053724b95966a57f41863ca41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]: /images/20221024/3fc32b91e68345889ee26086e931e032.png