vlambda博客
学习文章列表

1
2
3
4
5
6
7
8
9
10
11

/**
 *第一个方法被调用一次以初始化插件
 */
public synchronized void init(ProcessingEnvironment processingEnv)

/**
 * 在每次注释循环中被调用，在所有回合完成后再被调用一次
 * @return 这些annotations注解是否由此 Processor 处理，返回ture表示该注解已经被处理, 不会再有后续其他处理器处理进行处理; 返回false表示仍可被其他后续处理器处理
 */
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv)

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

/**
 * 注意,此例使用到了sun.tools中的类,可能会导致不稳定.
 * 开发者不应该调用sun包，Oracle一直在提醒开发者，调用sun.*包里面的方法是危险的。
 * sun包并不包含在Java平台的标准中，它与操作系统相关，
 * 在不同的操作系统如Solaris，Windows，Linux，Mac等中的实现也各不相同，并且可能随着JDK版本而变化。详细说明:
 * http://www.oracle.com/technetwork/java/faq-sun-packages-142232.html
 *
 * Created by arthinking on 30/1/2020.
 */
@SupportedAnnotationTypes("com.itzhai.annotation.process.demo.ForceAssertions")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class ForceAssertionsProcessor extends AbstractProcessor {

    // 计数器用于向用户报告已应用的替换次数
private int tally;

    // Trees JSR269的工具类,连接程序元素和树节点的桥梁。
// 例如，给定一个method元素，我们可以获得其关联的AST树节点
private Trees trees;

    // TreeMaker 编译器的内部组件,用于创建树节点的工厂
private TreeMaker make;

    // Name.Table 编译器的一个内部组件, Name是内部编译器字符串的抽象。
// 出于效率原因，Javac使用存储在公共大型缓冲区中的哈希字符串。
private Names names;

    @Override
public synchronized void init(ProcessingEnvironment env) {
super.init(env);
        trees = Trees.instance(env);
// 我们使用处理环境来处理必要的编译器组件。在编译器内，对编译器的每次调用都使用单个处理环境（或context上下文，内部称为上下文）。
// 把JSR269的ProcessingEnvironment转换为实际的编译器类型JavacProcessingEnvironment,以便能够调用更多的内部方法
        JavacProcessingEnvironment javacProcessingEnvironment = (JavacProcessingEnvironment)env;
// 使用context上下文来确保每个编译器调用都存在每个编译器组件的单个副本。
        Context context = javacProcessingEnvironment.getContext();
//  在编译器中，我们仅使用 Component.instance(context) 来获取对该阶段的引用
        make = TreeMaker.instance(context);
        names = Names.instance(context);
// tally 计数器用于向用户报告已应用的替换次数。
        tally = 0;
    }

    @Override
public boolean process(Set<? extends TypeElement> annotations,
 RoundEnvironment roundEnv) {
if (!roundEnv.processingOver()) {
// 遍历所有的程序元素,并且重写每个类的AST
            Set<? extends Element> elements = roundEnv.getRootElements();
for (Element each : elements) {
if (each.getKind() == ElementKind.CLASS) {
// 把JSR269的 Tree 转换为实际的JCTree类型,以便可以访问所有的AST元素。
                    JCTree tree = (JCTree) trees.getTree(each);
// 通过对TreeTranslator进行子类化来完成树翻译，
// TreeTranslator本身是TreeVisitor的子类。
// 这些类都不是JSR269的一部分，而是Java编译器内部的类。
                    TreeTranslator visitor = new Inliner();
                    tree.accept(visitor);
                }
            }
        } else {
// 输出处理的断言语句的数量
            processingEnv.getMessager().printMessage(
                    Diagnostic.Kind.NOTE, tally + " assertions inlined.");
        }
return false;
    }

    /**
     * Inliner类实现了AST的重写
     */
private class Inliner extends TreeTranslator {

        /**
         * 为了改变assert语句,我们这里重写了 visitAssert(JCAssert tree) 方法
         * @param tree
         */
@Override
public void visitAssert(JCAssert tree) {
// 必须调用超类方法,以确保将转换也应用于节点的子代。
super.visitAssert(tree);
// 改写逻辑在makeIfThrowException这个方法中,结果赋值给 TreeTranslator.result
            result = makeIfThrowException(tree);
            tally++;
        }

        /**
         * 具体的assert语句转换逻辑:
         * assert cond : detail;
         * 转换为:
         * if (!cond) throw new AssertionError(detail);
         *
         * 该方法将一个断言语句作为参数，并返回一个if语句。
         * 这是一个有效的返回值，因为两个树节点都是语句，因此与Java语法等效。
         *
         * @param node
         * @return
         */
private JCStatement makeIfThrowException(JCAssert node) {
// make: if (!(condition) throw new AssertionError(detail);
// 获取断言的 detail
            List<JCExpression> args = node.getDetail() == null
                    ? List.<JCExpression>nil()
                    : List.of(node.detail);
// 创建了一个AST节点，该节点创建了“AssertionError”的新实例。
            JCExpression expr = make.NewClass(
null,
null,
// 使用Name.Table获取编译器内部字符串表示形式
                    make.Ident(names.fromString("AssertionError")),
                    args,
null);
// 返回一个if语句
return make.If(
// 倒置 assert的条件
 make.Unary(JCTree.Tag.NOT, node.cond),
// 创建一个 throw 表达式
                    make.Throw(expr),
null);
        }
    }
}

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

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<!-- 设置为true以打印有关编译器相关的日志 -->
<verbose>true</verbose>
<!-- 允许在单独的进程中运行编译器。如果为false，则使用内置编译器；如果为true，则使用可执行文件。
                    要使compilerVersion标签生效，需要将fork设为true，用于明确表示编译版本配置可用
                    -->
<fork>true</fork>
<!-- 指定插件将使用的编译器的版本 -->
<compilerVersion>1.8</compilerVersion>
<!-- 源代码使用的JDK版本 -->
<source>1.8</source>
<!--<executable>${JAVA_HOME}/bin/javac</executable>-->
<!-- 需要生成的目标class文件的编译版本 -->
<target>1.8</target>
<!-- 需要生成的目标class文件的编译版本 -->
<encoding>utf-8</encoding>
<!--
					重点！
					https://stackoverflow.com/questions/38926255/maven-annotation-processing-processor-not-found
					默认的,编译器会找到Processor配置,并且执行注解处理器,但此时注解处理器还没编译好,所以会报错,为了避免这种错误,需要做一下参数配置:
					-->
<proc>none</proc>
<!-- 这个选项用来传递编译器自身不包含但是却支持的参数选项 -->
<compilerArguments>
<!-- 重点！自定义注解处理器使用到了 com.sun.tools 包中的类,所以这里要确保引用 tools.jar-->
<classpath>${JAVA_HOME}/lib/tools.jar</classpath>
</compilerArguments>
</configuration>
</plugin>

1

javac -processor org.checkerframework.checker.nullness.NullnessChecker Example.java