「JVM 编译优化」插入式注解处理器（自定义代码编译检查）

已于 2023-03-11 00:28:07 修改
阅读量632 收藏 2
点赞数 1
分类专栏： 《JVM 体系梳理》 文章标签： jvm java spring hibernate 代码规范
于 2023-02-19 18:37:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoming_h/article/details/129113080
版权

JDK 的编译子系统暴露给用户直接控制的功能相对很少，除了虚拟机即时编译的若干参数，便只有 JSR-296 中定义的插入式注解处理器 API；

文章目录

1. 目标

前端编译器在讲 Java 源码编译成字节码时对源码做了各方面检查，主要是看程序写到对不对，较少去看写得好不好，业界有一些如 CheckStyle、FindBug、Klocwork 等的工具用于检查代码好坏，有一些用于扫描 Java 源码，也有一些是扫描字节码；我们的目标是通过注解处理器 API 实现自己编码风格的校验工具：NameCheckProcessor；

根据《Java 语言规范》要求，Java 程序命名推荐使用如下书写规范：

  • 类（接口）：驼峰命名法，首字母大写；
  • 方法：驼峰命名法，首字母小写；
  • 字段
    • 类或实例变量：驼峰命名法，首字母小写；
    • 常量：全部由大写字母或下划线构成，第一个字符不能是下划线；

为 javac 编译器添加额外的功能，在编译程序时检查程序名是否符合上述对类、接口、方法、字段的命名要求；

2. 实现

注解处理器可以通过继承抽象类 javax.annotation.processing.AbstractProcessor 复写抽象方法 process() 来实现；javac 编译器在执行注解处理器代码时会调用 process()；

  • annotations，此注解处理器所要处理的注解集合；
  • roundEnv，当前这个轮次（Round）中的抽象语法树节点，每个语法树节点表示一个 Element；
  • processingEnv，AbstractProcessor 中的一个 protected 变量，代表了注解处理器框架提供的一个上下文环境，可用来创建新的代码、向编译器输出信息、获取其他工具类等；

javax.lang.model.ElementKind 定义了 18 类 Element，包含 Java 代码中可能出现的全部元素，如包（Package）、枚举（Enum）、类（Class）、注解（AnnotationType）、接口（Interface）、枚举值（EnumConstant）、字段（Field）、参数（Parameter）、本地变量（LocalVariable）、异常（ExceptionnParameter）、方法（Method）、构造函数（Constructor）、静态语句块（StaticInit，即 static{} 块）、实例语句块（InstanceInit，即 {} 块）、参数化类型（TypeParameter，泛型尖括号内的类型）、资源变量（ResourceVariable，try-resource 中定义的变量）、模块（Module）、未定义的其他语法树节点（Other）；

  • @SupportedAnnotationTypes，代表这个注解处理器对哪些注解感兴趣；
  • @SuppertedSourceVersion，表示这个注解处理器可以处理哪些版本的 Java 代码；

注解处理器 NameCheckProcessor


/**
 * "*" 表示支持所有 Annotations
 * 只支持 JDK 8 的 Java 代码
 *
 * @author Aurelius Shu
 * @since 2023-02-19
 */
@SupportedAnnotationTypes("*")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class NameCheckProcessor extends AbstractProcessor {

    private NameChecker nameChecker;

    /**
     * 初始化名称检查插件
     */
    @Override
    public void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        nameChecker = new NameChecker(processingEnv);
    }

    /**
     * 对输入的语法树的各个节点进行名称检查
     */
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (!roundEnv.processingOver()) {
            for (Element element : roundEnv.getRootElements())
                nameChecker.checkNames(element);
        }
        return false;
    }
}

命名检查器 NameChecker


/**
 * 程序名称规范的编译器插件
 * 如果程序命名不合规范，将会输出一个编译器的 WARNING 信息
 *
 * @author Aurelius Shu
 * @since 2023-02-19
 */
public class NameChecker {
    private final Messager messager;
    NameCheckScanner nameCheckScanner = new NameCheckScanner();

    NameChecker(ProcessingEnvironment processsingEnv) {
        this.messager = processsingEnv.getMessager();
    }

    /**
     * 对Java程序命名进行检查，根据《Java语言规范》第三版第 6.8 节的要求，Java程序命名应当符合下列格式: 
     * 类或接口:符合驼式命名法，首字母大写。
     * 方法:符合驼式命名法，首字母小写。
     * 字段:
     * 类、实例变量: 符合驼式命名法，首字母小写。
     * 常量: 要求全部大写。
     */
    public void checkNames(Element element) {
        nameCheckScanner.scan(element);
    }

    /**
     * 名称检查器实现类，继承了 JDK 8 中新提供的ElementScanner8<br> * 将会以 Visitor 模式访问抽象语法树中的元素
     */
    private class NameCheckScanner extends ElementScanner8<Void, Void> {
        /**
         * 此方法用于检查 Java 类
         */
        @Override
        public Void visitType(TypeElement e, Void p) {
            scan(e.getTypeParameters(), p);
            checkCamelCase(e, true);
            super.visitType(e, p);

            return null;
        }

        /**
         * 检查方法命名是否合法
         */
        @Override
        public Void visitExecutable(ExecutableElement e, Void p) {
            if (e.getKind() == METHOD) {
                Name name = e.getSimpleName();
                if (name.contentEquals(e.getEnclosingElement().getSimpleName())) {
                    messager.printMessage(WARNING, "一个普通方法 “" + name + "”不应当与类名重复，避免与构造函数产生混淆", e);
                }
                checkCamelCase(e, false);
            }
            super.visitExecutable(e, p);
            return null;
        }

        /**
         * 检查变量命名是否合法
         */
        @Override
        public Void visitVariable(VariableElement e, Void p) {
            // 如果这个Variable是枚举或常量，则按大写命名检查，否则按照驼式命名法规则检查
            if (e.getKind() == ENUM_CONSTANT || e.getConstantValue() != null || heuristicallyConstant(e))
                checkAllCaps(e);
            else checkCamelCase(e, false);
            return null;
        }

        /**
         * 判断一个变量是否是常量
         */
        private boolean heuristicallyConstant(VariableElement e) {
            if (e.getEnclosingElement().getKind() == INTERFACE) return true;
            else if (e.getKind() == FIELD && e.getModifiers().containsAll(EnumSet.of(PUBLIC, STATIC, FINAL)))
                return true;
            else {
                return false;
            }
        }

        /**
         * 检查传入的 Element 是否符合驼式命名法，如果不符合，则输出警告信息
         */
        private void checkCamelCase(Element e, boolean initialCaps) {
            String name = e.getSimpleName().toString();
            boolean previousUpper = false;
            boolean conventional = true;
            int firstCodePoint = name.codePointAt(0);
            if (Character.isUpperCase(firstCodePoint)) {
                previousUpper = true;
                if (!initialCaps) {
                    messager.printMessage(WARNING, "名称“" + name + "”应当以小写字母开头", e);
                    return;
                }
            } else if (Character.isLowerCase(firstCodePoint)) {
                if (initialCaps) {
                    messager.printMessage(WARNING, "名称“" + name + "”应当以大写字母开头", e);
                    return;
                }
            } else {
                conventional = false;
            }

            if (conventional) {
                int cp = firstCodePoint;
                for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
                    cp = name.codePointAt(i);
                    if (Character.isUpperCase(cp)) {
                        if (previousUpper) {
                            conventional = false;
                            break;
                        }

                    }
                }
                previousUpper = true;
            } else previousUpper = false;

            if (!conventional)
                messager.printMessage(WARNING, "名称“" + name + "”应当符合驼式命名法(Camel Case Names)", e);
        }

        /**
         * 大写命名检查，要求第一个字母必须是大写的英文字母，其余部分可以是下划线或大写字母
         */
        private void checkAllCaps(Element e) {
            String name = e.getSimpleName().toString();
            boolean conventional = true;
            int firstCodePoint = name.codePointAt(0);
            if (!Character.isUpperCase(firstCodePoint)) {
                conventional = false;
            } else {
                boolean previousUnderscore = false;
                int cp = firstCodePoint;
                for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
                    cp = name.codePointAt(i);
                    if (cp == (int) '_') {
                        if (previousUnderscore) {
                            conventional = false;
                            break;
                        }
                        previousUnderscore = true;
                    } else {
                        previousUnderscore = false;
                        if (!Character.isUpperCase(cp) && !Character.isDigit(cp)) {
                            conventional = false;
                            break;
                        }
                    }
                }
            }

            if (!conventional) {
                messager.printMessage(WARNING, "常量“" + name + "”应当全部以大写字母或下划线命名，并且以字母开头", e);
            }
        }
    }
}

NameChecker 通过继承 javax.lang.model.util.ElementScanner8 的 NameCheckScanner 类，以 Visitor 模式实现对语法树的遍历；通过 checkCamelCase() 与 checkAllCaps() 实现驼峰命名法和全大写命名的检查；分别在 visitType()、visitVariable()、visitExecutable() 中对类、字段、方法进行检查；

3. 运行与测试

不符合规范的代码演示

public class BADLY_NAMED_CODE {
    enum colors {
        red, blue, green;
    }

    static final int _FORTY_TWO = 42;
    public static int NOT_A_CONSTANT = _FORTY_TWO;

    protected void BADLY_NAMED_CODE() {
        return;
    }

    public void NOTcamelCASEmethodNAME() {
        return;
    }
}

运行注解处理器

# 编译注解处理器，切换到 src/main/java 路径
javac edu/aurelius/jvm/compiler/NameChecker.java
javac edu/aurelius/jvm/compiler/NameCheckProcessor.java

# 编译时运行注解处理器
javac -processor edu.aurelius.jvm.compiler.NameCheckProcessor edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java

检查效果

edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:7: warning: 名称“BADLY_NAMED_CODE”应当符合驼式命名法(Camel Case Names)
public class BADLY_NAMED_CODE {
       ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:8: warning: 名称“colors”应当以大写字母开头
    enum colors {
    ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:9: warning: 常量“red”应当全部以大写字母或下划线命名，并且以字母开头
        red, blue, green;
        ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:9: warning: 常量“blue”应当全部以大写字母或下划线命名，并且以字母开头
        red, blue, green;
             ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:9: warning: 常量“green”应当全部以大写字母或下划线命名，并且以字母开头
        red, blue, green;
                   ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:12: warning: 常量“_FORTY_TWO”应当全部以大写字母或下划线命名，并且以字母开头
    static final int _FORTY_TWO = 42;
                     ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:13: warning: 名称“NOT_A_CONSTANT”应当以小写字母开头
    public static int NOT_A_CONSTANT = _FORTY_TWO;
                      ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:15: warning: 一个普通方法 “BADLY_NAMED_CODE”不应当与类名重复，避免与构造函数产生混淆
    protected void BADLY_NAMED_CODE() {
                   ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:15: warning: 名称“BADLY_NAMED_CODE”应当以小写字母开头
    protected void BADLY_NAMED_CODE() {
                   ^
edu/aurelius/jvm/compiler/BADLY_NAMED_CODE.java:19: warning: 名称“NOTcamelCASEmethodNAME”应当以小写字母开头
    public void NOTcamelCASEmethodNAME() {
                ^
10 warnings

-XprintRounds、-XprintProcessorInfo 参数可以进一步跟踪注解处理器的运作详细信息；

4. 其他应用案例

  • 校验 Hibernate 标签的正确性（Hibernate Validator Annotation Processor）；
  • 自动为字段生成 getter、setter 方法等辅助内容（Lombok，根据已有元素生成新的语法树元素）；

上一篇：「JVM 编译优化」Java 语法糖（泛型、自动装箱/拆箱、条件编译）
下一篇：「JVM 编译优化」即时编译器

PS：感谢每一位志同道合者的阅读，欢迎关注、评论、赞！

参考资料：

  • [1]《深入理解 Java 虚拟机》
Aurelius-Shu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java查单源码-JavaSourceCodeRuleChecker:根据自定义Java规则检查源代码
05-24
java查单源码JavaSourceCodeRuleChecker 根据自定义Java规则检查源代码 这是用于帮助发现代码错误的工具。 您可以通过扩展ARule来创建自己的规则，并从IRule中实现getResults方法。 get results方法使用对象数组作为参数，因此您可以构建自定义规则以使用所需的任何对象。 getResults方法应返回一个哈希图，其中源文件为键，而ErrorLines数组为值。 ErrorLine只是具有行号和消息的类，通常该行本身就是消息，但是您可以将其更改为所需的任何内容。 在主类中，您可以将规则添加到rulesToCheck数组列表中并运行该应用程序。 确保更改项目的路径位置以匹配您的本地驱动器位置。
Java-JSR-269-插入式注解处理器
demon7552003的小本本
12-30 687
Java插入式注解处理器
插入式注解API(Pluggable Annotation Processing API)
老螺丝的技术人生
01-08 1141
;在JDK 1.5之后，Java语言提供了对注解（Annotation）的支持，这些注解与普通的Java代码一样，是在运行期间发挥作用的。在JDK 1.6中实现了JSR-269规范JSR-269：Pluggable Annotations Processing API（插入式注解处理API）。提供了一组插入式注解处理器的标准API在编译期间对注解进行处理。Annotation Processor在编译期间而不是运行期间处理Annotation, Annotation Processor相当于编译器的一个插件
【JVM知识】插入式注解处理器实现java编程规范检测
dylan的博客
12-17 546
插入式注解处理器实现java编程规范检测,实现插件有findbug、lombok、mapstruct等
项目终于用上了插入式注解，真香！
emprere的博客
02-06 72
点击关注公众号：互联网架构师，后台回复2T获取2TB学习资源！上一篇：2T架构师学习资料干货分享大家好，我是互联网架构师！插入式注解处理器在《深入理解Java虚拟机》一书中有一些介绍（前端编译篇有提到），但一直没有机会使用，直到碰到这个需求，觉得再合适不过了，就简单用了一下，这里做个记录。了解过lombok底层原理的都知道其使用的就是的插入式注解，那么今天笔者就以真实场景演示一下插入式注解的使用...
【实用工具】JSR-269 插入式注解处理器AbstractProcessor
秋装什么的博客
05-05 991
【实用工具】JSR-269 插入式注解处理器AbstractProcessor
JVM:早期(编译期)优化的深入理解
08-26
今天小编就为大家分享一篇关于JVM:早期(编译期)优化的深入理解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
JVM教程之Java代码编译和执行的整个过程（二）
08-30
主要介绍了JVM学习笔记第二篇，关于Java代码编译和执行的整个过程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
xgboost jvm下编译好的
11-02
这个有问题，不要审核通过，修改好再上传，ubuntu中编译好的，jvm packages下执行好的，jar包在jvm-packages下对应的target文件夹下
xgboost 编译好的 jvm
11-02
上传错了，不能删除，不要审核通过啊。。。。。。。。。。。。
jvm指令手册 +JVM必知必会，掌握虚拟机编译过程.rar
11-09
JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 引入Java语言虚拟机后，Java语言在不同平台...
Java JSR-269 插入式注解处理器
spring的博客
08-10 2708
在Javac源码中，插入式注解处理器的初始化过程是在方法中完成的，而它的执行过程则是在方法中完成的，这个方法判断是否还有新的注解处理器需要执行，如果有的话，通过类的 **doProcessing()**方法生成一个新的JavaCompiler对象对编译的后续步骤进行处理。在JDK1.5之后，Java语言提供了对注解（Annotation）的支持，这些注解与普通的Java代码一样，是在运行期间发挥作用的。.........
JVM--插入式注解处理器
书香水墨
01-22 2059
@Target({ElementType.METHOD}) @Retention(RetentionPolicy.SOURCE) @Documented public @interface TakeTime { /** * 标记前缀,无实质作用,只是为了方便查找 * @return */ String tag() default ""; } package cn.kanyun.annotation_processor.taketime; import com
java 注解处理器_JAVA 插入注解处理器
weixin_31256683的博客
02-22 575
JDK1.5后，Java语言提供了对注解(Annotation)的支持JDK1.6中提供一组插件式注解处理器的标准API，可以实现API自定义注解处理器，干涉编译器的行为。在这里,注解处理器可以看作编译器的插件，在编译期间对注解进行处理，可以对语法树进行读取、修改、添加任意元素；但如果有注解处理器修改了语法树，编译器将返回解析及填充符号表的过程，重新处理，直到没有注解处理器修改为止，每一次重新处理...
项目终于用上了插入式注解，真香
m0_74931226的博客
12-28 211
插入式注解处理器在《深入理解Java虚拟机》一书中有一些介绍（前端编译篇有提到），但一直没有机会使用，直到碰到这个需求，觉得再合适不过了，就简单用了一下，这里做个记录。了解过lombok底层原理的都知道其使用的就是的插入式注解，那么今天笔者就以真实场景演示一下插入式注解的使用。
Java虚拟机（JVM）中确保资源及时释放的策略
最新发布
weixin_41247583的博客
05-10 192
Java开发者通常不需要（也不应该）显式地释放对象内存，因为JVM的垃圾回收器会自动处理不再使用的对象。简单总结一下，虽然在Java中不能像在一些其他语言（如C/C++）那样显式地释放内存，但通过合理管理资源引用和使用适当的资源管理技术，你可以有效地控制内存使用和资源回收。在某些情况下，你可以使用弱引用（WeakReference）或软引用（SoftReference），这些引用类型允许对象在JVM需要内存时被垃圾回收器回收。一旦一个对象没有任何强引用指向，它就会成为垃圾回收的候选对象。
gradle 设置jvm编译大小
05-30
你可以通过在 Gradle 的 `build.gradle` 文件中设置 `compileJava` 任务的 `options` 属性来指定 JVM 编译大小。具体而言，你需要在 `options` 属性中添加 `-Xmx` 参数，例如： ``` compileJava { options.compilerArgs << "-Xmx2g" } ``` 这将为 `compileJava` 任务设置一个最大堆大小为 2GB 的 JVM。你可以根据需要调整这个值，例如使用 `-Xmx4g` 来设置一个 4GB 的 JVM。注意，这个值应该根据你的项目的规模和需求进行调整，设置太小可能导致编译失败。 除了在 `compileJava` 任务中设置 JVM 大小外，你也可以在 Gradle 的 `gradle.properties` 文件中设置全局 JVM 大小，这将影响所有 Gradle 任务的 JVM 大小。你可以在 `gradle.properties` 文件中添加以下内容： ``` org.gradle.jvmargs=-Xmx2g ``` 这将为所有 Gradle 任务设置一个最大堆大小为 2GB 的 JVM。同样，你也可以根据需要调整这个值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Aurelius-Shu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值