浅析Java插件化注解API原理与实战

已于 2022-02-13 15:03:09 修改
阅读量1k 收藏 2
点赞数 2
文章标签： java maven javac jvm annotations
于 2022-02-11 00:38:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41960425/article/details/122850726
版权

目录

一、Java编译期注解VS运行期注解

编译期注解运行时注解
优点模版化代码，代码更简洁，提高开发效率，性能较高可读性强，灵活，易调试
缺点代码侵入性强，调试困难，可维护性差性能较差

二、Javac生成.class文件流程

  1. 准备过程：初始化插入式注解处理器。
  2. 解析与填充符号表过程，包括：
    ·词法、语法分析。将源代码的字符流转变为标记集合，构造出抽象语法树。
    ·填充符号表。产生符号地址和符号信息。
  3. 插入式注解处理器的注解处理。
  4. 分析与字节码生成过程，包括：
    ·标注检查。对语法的静态信息进行检查。
    ·数据流及控制流分析。对程序动态运行过程进行检查。
    ·解语法糖。将简化代码编写的语法糖还原为原有的形式。
    ·字节码生成。将前面各个步骤所生成的信息转化成字节码。

com.sun.tools.javac.main.JavaCompiler中的核心编译代码

参考《深入理解Java虚拟机：JVM高级特性与最佳实践（第3版） - 周志明》

三、插件化注解API（Pluggable Annotation Processing API）

1、概念

按照 JSR269标准提供的一种API来操作annotation，它旨在通过编译期注解模版化地生成代码。
可以把插入式注解处理器看作是一组编译器的插件，如果这些插件在处理注解期间对语法树进行过修改，编译器将回到解析及填充符号表的过程重新处理，直到所有插入式注解处理器都没有再对语法树进行修改为止。

2、使用步骤

  1. 自定义一个元注解为@Retention(RetentionPolicy.SOURCE)的注解
  2. 自定义一个继承至javax.annotation.processing.AbstractProcessor的Processor来处理注解
  3. 用自定义的Processor来编译Java文件，并指定其所支持的注解
  4. 将自定义注解标注在自己所需要的地方！

3、关键类

JCTree.java 语法树节点的基类

TreeMaker.java 用于构建语法树节点

TreeTranslator.java 继承自JCTree.Vistor类，可以访问所有语法树节点，并对其进行代码侵入

4、案例

Talk is cheap. Show me the code

  1. 这里以一个多模块maven项目为例，项目结构如下，启动类为DemoApplication.java。
    这里的案例为做这件事：将HTTP请求和返回的空字符串统一置为null
  1. 仅在编译期生效的元注解
package com.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.SOURCE)
public @interface RewriteEmptyStringAsNull {}
  1. 自定义Processor,
/*
 *MyProcessor.java
 */
package com.demo.processor;

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;

import com.google.auto.service.AutoService;
import com.sun.source.util.Trees;
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;

// Google提供的注解，用于注册Java SPI
@AutoService(Processor.class)
// Processor对哪些注解生效
@SupportedAnnotationTypes({"com.demo.annotation.*"})
public class MyProcessor extends AbstractProcessor {

    /**
     * 语法树集合
     */
    private Trees trees;
    /*
     * 修改语法树的工具类
     */
    private TreeMaker treeMaker;

    /**
     * 给语法树元素命名的工具类
     */
    private Names names;

    /**
     * 用来打印错误信息
     */
    private Messager messager;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.messager = processingEnv.getMessager();
        this.trees = Trees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (!roundEnv.processingOver()) {
            // 遍历每个被注解标记的元素
            for (Element element : roundEnv.getRootElements()) {
                if (element.getKind().isClass()) {
                    // 获取语法树
                    JCTree tree = (JCTree) trees.getTree(element);
                    // 使用TreeTranslator遍历
                    tree.accept(new MyTreeTranslator(treeMaker, names));
                }
            }
        }
        // 是否继续让其他processor处理
        return false;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }
}


/*
* MyTreeTranslator.java
*/
package com.demo.processor;

import static com.sun.tools.javac.tree.JCTree.JCAnnotation;
import static com.sun.tools.javac.tree.JCTree.JCBlock;
import static com.sun.tools.javac.tree.JCTree.JCModifiers;
import static com.sun.tools.javac.tree.JCTree.JCVariableDecl;

import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.TreeTranslator;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Names;

import com.demo.annotation.RewriteEmptyStringAsNull;

public class MyTreeTranslator extends TreeTranslator {

    /**
     * 树节点创建工具类
     */
    private TreeMaker treeMaker;
    /**
     * 命名工具类
     */
    private Names names;
    /**
     * 需要插入的Setter方法
     */
    private List<JCTree> setters = List.nil();

    public MyTreeTranslator(TreeMaker treeMaker, Names names) {
        this.treeMaker = treeMaker;
        this.names = names;
    }

    /**
     * 遍历到类时执行
     */
    @Override
    public void visitClassDef(JCClassDecl jcClassDecl) {
        super.visitClassDef(jcClassDecl);
        // 插入setter方法
        if (!setters.isEmpty()) {
            jcClassDecl.defs = jcClassDecl.defs.appendList(this.setters);
        }
        this.result = jcClassDecl;
    }

    /**
     * 遍历成员时执行
     */
    @Override
    public void visitVarDef(JCVariableDecl jcVariableDecl) {
        super.visitVarDef(jcVariableDecl);
        JCModifiers modifiers = jcVariableDecl.getModifiers();
        List<JCAnnotation> annotations = modifiers.getAnnotations();
        if (annotations == null || annotations.size() <= 0) {
            return;
        }
        // 以下只是简单实现, 不考虑是否已存在setter方法
        for (JCAnnotation annotation : annotations) {
            if (RewriteEmptyStringAsNull.class.getName().equals(annotation.type.toString())) {
                // 生成getter方法
                JCMethodDecl setterMethod = createSetterMethod(jcVariableDecl);
                this.setters = this.setters.append(setterMethod);
            }

        }
    }

    /**
     * 创建Setter方法
     */
    private JCMethodDecl createSetterMethod(JCVariableDecl field) {
        // 定义方法传入的参数
        JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), field.name, field.vartype, null);

        /*
                 if("".equals(name)){
                        this.name = null;
                  }else{
                        this.name = name;
                  }
         */

        // "".equals(name)               ---方法调用节点
        JCTree.JCMethodInvocation judgeStat = treeMaker.Apply(
                // 参数类型列表
                List.nil(),
                // "".equals    ---调用语句
                treeMaker.Select(
                        // . 左边的内容， 被调用的实体
                        treeMaker.Literal(""),
                        // . 右边的内容， 调用方法名/变量名等
                        names.fromString("equals")
                ),
                // name  ---方法调用的传参
                List.of(treeMaker.Ident(field.name))
        );

        // this.name = null   --- 可执行语句节点
        JCTree.JCExpressionStatement ifStat = treeMaker.Exec(
                // 赋值语句节点
                treeMaker.Assign(
                        // = 左边的语句
                        treeMaker.Select(treeMaker.Ident(names.fromString("this")), field.name),
                        // = 右边的语句
                        treeMaker.Literal(TypeTag.BOT,null)
                )
        );

        // this.name = name   --- 可执行语句节点
        JCTree.JCExpressionStatement elseStat = treeMaker.Exec(
                // 赋值语句节点
                treeMaker.Assign(
                        // = 左边的语句
                        treeMaker.Select(treeMaker.Ident(names.fromString("this")), field.name),
                        // = 右边的语句
                        treeMaker.Ident(field.name)
                )
        );

        

        JCBlock methodBody = treeMaker.Block(0L, List.of(treeMaker.If(
                // 判断语句
                judgeStat,
                // 条件成立的语句
                ifStat,
                // 条件不成立的语句
                elseStat  
        )));

        return treeMaker.MethodDef(
                // public方法
                treeMaker.Modifiers(Flags.PUBLIC),
                // 方法名称
                names.fromString("set" + this.toTitleCase(field.getName().toString())),
                // 方法返回的类型
                treeMaker.Type(new Type.JCVoidType()),
                // 泛型参数
                List.nil(),
                // 方法参数
                List.of(param),
                // throw表达式
                List.nil(),
                // 方法体
                methodBody,
                // 默认值
                null
        );
    }

    /**
     * 首字母大写
     */
    public String toTitleCase(String str) {
        char first = str.charAt(0);
        if (first >= 'a' && first <= 'z') {
            first -= 32;
        }
        return first + str.substring(1);
    }
}
  1. 用自定义Processor来编译java文件
    推荐使用Java SPI来注册指定Processor，有两种方式
  • 在自定义的Processor上添加注解`@AutoService({Processor.class})
  • 新增文件src/main/resources/META-INF/services/javax.annotation.processing.Processor 内容为自定义Processor的全限定名，如com.demo.processor.MyProcessor
  1. 效果演示
/*
* HelloWorldController.java
*/
package com.demo.controller;

import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.demo.vo.Hello1Req;
import com.demo.vo.Hello2Req;

@RestController
public class HelloWorldController {

    @RequestMapping("/hello1")
    public Object hello1(@RequestBody Hello1Req hello1Req) {
        return hello1Req;
    }

    @RequestMapping("/hello2")
    public Object hello2(@RequestBody Hello2Req hello2Req) {
        return hello2Req;
    }
}


/*
* Hello1Req.java
*/
package com.demo.vo;

import lombok.Data;

@Data
public class Hello1Req {
	private String str1;
	private String str2;
}

/*
* Hello2Req.java
*/
package com.demo.vo;


import com.demo.annotation.RewriteEmptyStringAsNull;

import lombok.Getter;

public class Hello2Req {

	@Getter
	@RewriteEmptyStringAsNull
	private String str1;
	@Getter
	@RewriteEmptyStringAsNull
	private String str2;
}

4.1 Rebuild Project 查看class文件
成功生成自定义方法
请添加图片描述
4.2 接口调用，查看是否成功实现：将HTTP请求和返回的空字符串统一置为null
启动springboot项目，分别调用这两个方法
Request1

curl -X POST localhost:8080/hello1 \
--header 'Content-Type: application/json' \
--data '{
	"str1":"哈哈",
	"str2":""
}'

Request2

curl -X POST localhost:8080/hello2 \
--header 'Content-Type: application/json' \
--data '{
	"str1":"哈哈",
	"str2":""
}'

结果
在这里插入图片描述

5、Tips

  1. 如何debug自定义的processor？
    打好断点后，通过调试javac源码，即debug如下的main方法
public static void main(String[] args)throws Exception {
        com.sun.tools.javac.Main.main(new String[] {"-proc:only",
                "-processor",
                // processor全限定名
                "com.demo.processor.MyProcessor",
                // 需要编译的文件路径
                "/Users/Project/test/demo-main/src/main/java/com/demo/vo/Hello2Req.java"});

//        SpringApplication.run(DemoApplication.class, args);
    }
  1. 如何规避IDEA的编译期语法检查？

在Preferences | Build, Execution, Deployment | Compiler
的Shared build process VM options 添加
-Djps.track.ap.dependencies=false

  1. 自定义Processor必须在注解标注的类之前编译，换句话说，注解标注的类必须经过Processor进行编译。因此建议把Processor写在另一个模块，通过maven引用此依赖来强制指定编译顺序。
热心小伙chj
关注
java中JTree高级编程
02-09
java中的关于jtree编程的详细介绍，通过jtree的使用，掌握模型设计的核心技术，同时丰富了java界面的美观度和实用度。
Java Annotation AbstractProcessor，通过AST修改class文件，修改方法定时任务注解，编译期解耦第三方组件
殷长庆的博客
09-24 1491
自定义一个定时器注解，我把spring的Scheduled注解作为自定义注解的结构体，方便我们编译时替换。@Retention(RetentionPolicy.SOURCE)// 编译期注解}
java的注解
最新发布
weixin_55605689的博客
08-16 1017
使用。
插入式注解API(Pluggable Annotation Processing API)
老螺丝的技术人生
01-08 1266
;在JDK 1.5之后，Java语言提供了对注解（Annotation）的支持，这些注解与普通的Java代码一样，是在运行期间发挥作用的。在JDK 1.6中实现了JSR-269规范JSR-269：Pluggable Annotations Processing API（插入式注解处理API）。提供了一组插入式注解处理器的标准API在编译期间对注解进行处理。Annotation Processor在编译期间而不是运行期间处理Annotation, Annotation Processor相当于编译器的一个插件
Java抽象语法树AST，JCTree 分析
lazyjam的博客
05-10 6610
JCTree简要分析 文章目录JCTree简要分析JCAnnotatedTypeJCAnnotationJCArrayAccessJCArrayTypeTreeJCAssertJCAssignJCAssignOpJCBinaryJCBlockJCBreakJCCaseJCCatchJCClassDeclJCCompilationUnitJCConditionalJCContinueJCDoWhil...
Java Annotation之应用篇 – 运行期动态解析annotation
部落阁
11-23 413
这样说来，annotation到底能起什么作用呢？ 1，    编译工具或其他工具可以根据被附加在代码里的annotation信息自动生成配置文件或文档等外部文件。 比如，sun公司就提供了apt（Annotation Processing Tool）工具，apt工具是一个可以处理annotation的命令行工具，apt提供了在编译期针对源代码级别的解析，并可以在解析时生成新的源代码和其他文件
插件化注解处理API(Pluggable Annotation Processing API)——JSR269规范
ni_hao_fan的博客
08-13 5991
简介 插件化注解处理(Pluggable Annotation Processing)APIJSR 269提供一套标准API来处理AnnotationsJSR 175,实际上JSR 269不仅仅用来处理Annotation，我觉得更强大的功能是它建立了Java 语言本身的一个模型,它把method、package、constructor、type、variable、enum、annotation等...
深入浅析Java Object Serialization与 Hadoop 序列化
08-30
深入浅析Java Object Serialization与 Hadoop 序列化 序列化是指将结构化对象转化为字节流以便在网络上传输或者写到磁盘永久存储的过程。Java 中的序列化是通过实现 Serializable 接口来实现的，而 Hadoop 序列化则...
浅析Java 9 Optional API 新增方法
08-25
在Java 9中，Optional API得到了进一步的增强，新增了三个方法来帮助开发者更优雅地处理可能缺失的值。这些新方法旨在提供更加灵活和安全的编程方式，减少空指针异常的风险，同时提高代码的可读性和简洁性。下面我们...
浅析办公自动化与电子政务最终版.pdf
11-16
浅析办公自动化与电子政务最终版.pdf
Java 读写锁实现原理浅析
08-27
"Java 读写锁实现原理浅析" Java 读写锁实现原理浅析是 Java 并发编程中一个非常重要的主题。在多线程编程中，读写锁是解决读写并发问题的常用机制。本文主要介绍了 Java 读写锁实现原理浅析，包括读写锁的定义、...
浅析办公自动化的应用与开发最终版.pdf
11-17
浅析办公自动化的应用与开发最终版.pdf
JAVA注解处理API实战
demon7552003的小本本
12-30 4589
插件化注解处理(Pluggable Annotation Processing)API
Java奇技淫巧-插件化注解处理API(Pluggable Annotation Processing API
Jaemon
11-14 712
Java奇技淫巧-插件化注解处理API(Pluggable Annotation Processing API
java抽象语法树_Java抽象语法树AST，JCTree 分析
weixin_33656238的博客
02-12 792
JCTree简要分析文章目录JCTree简要分析JCAnnotatedTypeJCAnnotationJCArrayAccessJCArrayTypeTreeJCAssertJCAssignJCAssignOpJCBinaryJCBlockJCBreakJCCaseJCCatchJCClassDeclJCCompilationUnitJCConditionalJCContinueJCDoWhile...
Java插件思路（SPI机制）
Nonoas的博客
10-17 2566
SPI（Service Provider Interface），是JDK内置的一种 服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用，比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和Oracle都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。Java 中 SPI 机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是解耦。
插件化开发探索与实践
余衫马的博客
03-05 3180
插件化开发入门
java注解常用api
吕小医的博客
05-09 459
java中元注解有四个： @Retention @Target @Document @Inherited； @Retention：注解的保留位置 @Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含 @Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得， @Retention(RetentionPolicy.RUNTIME) // 注解会在c
【工作笔记】Pluggable Annotation Processing API
lbh_paopao的博客
02-01 883
起因 简单的说就是我不想手写 model 里边的 builder 了，就问度娘类似 lombok 里边 @Builder 功能实现的原理，打算自己实现一个。于是便有了此文，此文质量好全靠度娘，质量差全赖我，反正我懒。。。 介绍 APIJSR 269 提供一套标准 API（Pluggable Annotation Processing）来处理 Annotations JSR 175，JSR 269 用 Annotation Processor 在编译期间而不是运行期间处理 Annotation，Annotat
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

热心小伙chj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值