Java中的屠龙之术——如何修改语法树

发表于

在Lombok经常用，但是你知道它的原理是什么吗？，和Lombok经常用，但是你知道它的原理是什么吗？(二)两篇文章中介绍了关于Lombok的底层原理，其实总结为一句话来说就是在编译期通过改变抽象语法树而实现的。上面两篇文章已经讲了抽象语法树的相关知识点，如果有不清楚的可以看一下。

本篇涉及到的所有代码都在github上面有

本篇涉及到的所有代码都在github上面有

本篇涉及到的所有代码都在github上面有

在网上关于如何修改Java的抽象语法树的相关API文档并不多，于是本篇记录一下相关的知识点，以便随后查阅。

JCTree的介绍

JCTree是语法树元素的基类，包含一个重要的字段pos，该字段用于指明当前语法树节点（JCTree）在语法树中的位置，因此我们不能直接用new关键字来创建语法树节点，即使创建了也没有意义。此外，结合访问者模式，将数据结构与数据的处理进行解耦，部分源码如下：

1
2
3
4
5
6
7
8
9
10
复制代码 1public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {  
 2  
 3    public int pos = -1;  
 4  
 5    ...  
 6  
 7    public abstract void accept(JCTree.Visitor visitor);  
 8  
 9    ...  
10}

我们可以看到JCTree是一个抽象类，这里重点介绍几个JCTree的子类

  1. JCStatement：声明语法树节点，常见的子类如下
    • JCBlock：语句块语法树节点
    • JCReturn：return语句语法树节点
    • JCClassDecl：类定义语法树节点
    • JCVariableDecl：字段/变量定义语法树节点
  2. JCMethodDecl：方法定义语法树节点
  3. JCModifiers：访问标志语法树节点
  4. JCExpression：表达式语法树节点，常见的子类如下
    • JCAssign：赋值语句语法树节点
    • JCIdent：标识符语法树节点，可以是变量，类型，关键字等等

TreeMaker介绍

TreeMaker用于创建一系列的语法树节点，我们上面说了创建JCTree不能直接使用new关键字来创建，所以Java为我们提供了一个工具，就是TreeMaker，它会在创建时为我们创建的JCTree对象设置pos字段，所以必须使用上下文相关的TreeMaker对象来创建语法树节点。

具体的API介绍可以参照，TreeMakerAPI，接下来着重介绍一下常用的几个方法。

TreeMaker.Modifiers

TreeMaker.Modifiers方法用于创建访问标志语法树节点（JCModifiers），源码如下

1
2
3
4
5
6
7
8
9
10
11
复制代码 1public JCModifiers Modifiers(long flags) {  
 2    return Modifiers(flags, List.< JCAnnotation >nil());  
 3}  
 4  
 5public JCModifiers Modifiers(long flags,  
 6    List<JCAnnotation> annotations) {  
 7        JCModifiers tree = new JCModifiers(flags, annotations);  
 8        boolean noFlags = (flags & (Flags.ModifierFlags | Flags.ANNOTATION)) == 0;  
 9        tree.pos = (noFlags && annotations.isEmpty()) ? Position.NOPOS : pos;  
10        return tree;  
11}
  1. flags：访问标志
  2. annotations：注解列表

其中flags可以使用枚举类com.sun.tools.javac.code.Flags来表示，例如我们可以这样用，就生成了下面的访问标志了。

1
2
3
复制代码1treeMaker.Modifiers(Flags.PUBLIC + Flags.STATIC + Flags.FINAL);  
2  
3public static final

TreeMaker.ClassDef

TreeMaker.ClassDef用于创建类定义语法树节点（JCClassDecl）,源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
复制代码 1public JCClassDecl ClassDef(JCModifiers mods,  
 2    Name name,  
 3    List<JCTypeParameter> typarams,  
 4    JCExpression extending,  
 5    List<JCExpression> implementing,  
 6    List<JCTree> defs) {  
 7        JCClassDecl tree = new JCClassDecl(mods,  
 8                                     name,  
 9                                     typarams,  
10                                     extending,  
11                                     implementing,  
12                                     defs,  
13                                     null);  
14        tree.pos = pos;  
15        return tree;  
16}
  1. mods：访问标志，可以通过TreeMaker.Modifiers来创建
  2. name：类名
  3. typarams：泛型参数列表
  4. extending：父类
  5. implementing：实现的接口
  6. defs：类定义的详细语句，包括字段、方法的定义等等

TreeMaker.MethodDef

TreeMaker.MethodDef用于创建方法定义语法树节点（JCMethodDecl），源码如下

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
复制代码 1public JCMethodDecl MethodDef(JCModifiers mods,  
 2    Name name,  
 3    JCExpression restype,  
 4    List<JCTypeParameter> typarams,  
 5    List<JCVariableDecl> params,  
 6    List<JCExpression> thrown,  
 7    JCBlock body,  
 8    JCExpression defaultValue) {  
 9        JCMethodDecl tree = new JCMethodDecl(mods,  
10                                       name,  
11                                       restype,  
12                                       typarams,  
13                                       params,  
14                                       thrown,  
15                                       body,  
16                                       defaultValue,  
17                                       null);  
18        tree.pos = pos;  
19        return tree;  
20}  
21  
22public JCMethodDecl MethodDef(MethodSymbol m,  
23    Type mtype,  
24    JCBlock body) {  
25        return (JCMethodDecl)  
26            new JCMethodDecl(  
27                Modifiers(m.flags(), Annotations(m.getAnnotationMirrors())),  
28                m.name,  
29                Type(mtype.getReturnType()),  
30                TypeParams(mtype.getTypeArguments()),  
31                Params(mtype.getParameterTypes(), m),  
32                Types(mtype.getThrownTypes()),  
33                body,  
34                null,  
35                m).setPos(pos).setType(mtype);  
36}
  1. mods：访问标志
  2. name：方法名
  3. restype：返回类型
  4. typarams：泛型参数列表
  5. params：参数列表
  6. thrown：异常声明列表
  7. body：方法体
  8. defaultValue：默认方法（可能是interface中的哪个default）
  9. m：方法符号
  10. mtype：方法类型。包含多种类型，泛型参数类型、方法参数类型、异常参数类型、返回参数类型。

返回类型restype填写null或者treeMaker.TypeIdent(TypeTag.VOID)都代表返回void类型

TreeMaker.VarDef

TreeMaker.VarDef用于创建字段/变量定义语法树节点（JCVariableDecl），源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
复制代码 1public JCVariableDecl VarDef(JCModifiers mods,  
 2    Name name,  
 3    JCExpression vartype,  
 4    JCExpression init) {  
 5        JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);  
 6        tree.pos = pos;  
 7        return tree;  
 8}  
 9  
10public JCVariableDecl VarDef(VarSymbol v,  
11    JCExpression init) {  
12        return (JCVariableDecl)  
13            new JCVariableDecl(  
14                Modifiers(v.flags(), Annotations(v.getAnnotationMirrors())),  
15                v.name,  
16                Type(v.type),  
17                init,  
18                v).setPos(pos).setType(v.type);  
19}
  1. mods：访问标志
  2. name：参数名称
  3. vartype：类型
  4. init：初始化语句
  5. v：变量符号

TreeMaker.Ident

TreeMaker.Ident用于创建标识符语法树节点（JCIdent），源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
复制代码 1public JCIdent Ident(Name name) {  
 2        JCIdent tree = new JCIdent(name, null);  
 3        tree.pos = pos;  
 4        return tree;  
 5}  
 6  
 7public JCIdent Ident(Symbol sym) {  
 8        return (JCIdent)new JCIdent((sym.name != names.empty)  
 9                                ? sym.name  
10                                : sym.flatName(), sym)  
11            .setPos(pos)  
12            .setType(sym.type);  
13}  
14  
15public JCExpression Ident(JCVariableDecl param) {  
16        return Ident(param.sym);  
17}

TreeMaker.Return

TreeMaker.Return用于创建return语句（JCReturn），源码如下

1
2
3
4
5
复制代码1public JCReturn Return(JCExpression expr) {  
2        JCReturn tree = new JCReturn(expr);  
3        tree.pos = pos;  
4        return tree;  
5}

TreeMaker.Select

TreeMaker.Select用于创建域访问/方法访问（这里的方法访问只是取到名字，方法的调用需要用TreeMaker.Apply）语法树节点（JCFieldAccess），源码如下

1
2
3
4
5
6
7
8
9
10
11
12
复制代码 1public JCFieldAccess Select(JCExpression selected,  
 2    Name selector)   
 3{  
 4        JCFieldAccess tree = new JCFieldAccess(selected, selector, null);  
 5        tree.pos = pos;  
 6        return tree;  
 7}  
 8  
 9public JCExpression Select(JCExpression base,  
10    Symbol sym) {  
11        return new JCFieldAccess(base, sym.name, sym).setPos(pos).setType(sym.type);  
12}
  1. selected：.运算符左边的表达式
  2. selector：.运算符右边的表达式

下面给出一个例子，一语句生成的Java语句就是二语句

1
2
3
复制代码1一. TreeMaker.Select(treeMaker.Ident(names.fromString("this")), names.fromString("name"));  
2  
3二. this.name

TreeMaker.NewClass

TreeMaker.NewClass用于创建new语句语法树节点（JCNewClass）,源码如下：

1
2
3
4
5
6
7
8
9
复制代码1public JCNewClass NewClass(JCExpression encl,  
2    List<JCExpression> typeargs,  
3    JCExpression clazz,  
4    List<JCExpression> args,  
5    JCClassDecl def) {  
6        JCNewClass tree = new JCNewClass(encl, typeargs, clazz, args, def);  
7        tree.pos = pos;  
8        return tree;  
9}
  1. encl：不太明白此参数的含义，我看很多例子中此参数都设置为null
  2. typeargs：参数类型列表
  3. clazz：待创建对象的类型
  4. args：参数列表
  5. def：类定义

TreeMaker.Apply

TreeMaker.Apply用于创建方法调用语法树节点（JCMethodInvocation），源码如下：

1
2
3
4
5
6
7
复制代码1public JCMethodInvocation Apply(List<JCExpression> typeargs,  
2    JCExpression fn,  
3    List<JCExpression> args) {  
4        JCMethodInvocation tree = new JCMethodInvocation(typeargs, fn, args);  
5        tree.pos = pos;  
6        return tree;  
7}
  1. typeargs：参数类型列表
  2. fn：调用语句
  3. args：参数列表

TreeMaker.Assign

TreeMaker.Assign用户创建赋值语句语法树节点（JCAssign），源码如下：

1
2
3
4
5
6
复制代码1ublic JCAssign Assign(JCExpression lhs,  
2    JCExpression rhs) {  
3        JCAssign tree = new JCAssign(lhs, rhs);  
4        tree.pos = pos;  
5        return tree;  
6}
  1. lhs：赋值语句左边表达式
  2. rhs：赋值语句右边表达式

TreeMaker.Exec

TreeMaker.Exec用于创建可执行语句语法树节点（JCExpressionStatement），源码如下：

1
2
3
4
5
复制代码1public JCExpressionStatement Exec(JCExpression expr) {  
2        JCExpressionStatement tree = new JCExpressionStatement(expr);  
3        tree.pos = pos;  
4        return tree;  
5}

TreeMaker.Apply以及TreeMaker.Assign就需要外面包一层TreeMaker.Exec来获得一个JCExpressionStatement

TreeMaker.Block

TreeMaker.Block用于创建组合语句的语法树节点（JCBlock），源码如下：

1
2
3
4
5
6
复制代码1public JCBlock Block(long flags,  
2    List<JCStatement> stats) {  
3        JCBlock tree = new JCBlock(flags, stats);  
4        tree.pos = pos;  
5        return tree;  
6}
  1. flags：访问标志
  2. stats：语句列表

com.sun.tools.javac.util.List介绍

在我们操作抽象语法树的时候，有时会涉及到关于List的操作，但是这个List不是我们经常使用的java.util.List而是com.sun.tools.javac.util.List，这个List比较奇怪，是一个链式的结构，有头结点和尾节点，但是只有尾节点是一个List，这里作为了解就行了。

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
复制代码 1public class List<A> extends AbstractCollection<A> implements java.util.List<A> {  
 2    public A head;  
 3    public List<A> tail;  
 4    private static final List<?> EMPTY_LIST = new List<Object>((Object)null, (List)null) {  
 5        public List<Object> setTail(List<Object> var1) {  
 6            throw new UnsupportedOperationException();  
 7        }  
 8  
 9        public boolean isEmpty() {  
10            return true;  
11        }  
12    };  
13  
14    List(A head, List<A> tail) {  
15        this.tail = tail;  
16        this.head = head;  
17    }  
18  
19    public static <A> List<A> nil() {  
20        return EMPTY_LIST;  
21    }  
22  
23    public List<A> prepend(A var1) {  
24        return new List(var1, this);  
25    }  
26  
27    public List<A> append(A var1) {  
28        return of(var1).prependList(this);  
29    }  
30  
31    public static <A> List<A> of(A var0) {  
32        return new List(var0, nil());  
33    }  
34  
35    public static <A> List<A> of(A var0, A var1) {  
36        return new List(var0, of(var1));  
37    }  
38  
39    public static <A> List<A> of(A var0, A var1, A var2) {  
40        return new List(var0, of(var1, var2));  
41    }  
42  
43    public static <A> List<A> of(A var0, A var1, A var2, A... var3) {  
44        return new List(var0, new List(var1, new List(var2, from(var3))));  
45    }  
46  
47    ...  
48}

com.sun.tools.javac.util.ListBuffer

由于com.sun.tools.javac.util.List使用起来不方便，所以又在其上面封装了一层，这个封装类是ListBuffer，此类的操作和我们平时经常使用的java.util.List用法非常类似。

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
复制代码 1public class ListBuffer<A> extends AbstractQueue<A> {  
 2  
 3    public static <T> ListBuffer<T> of(T x) {  
 4        ListBuffer<T> lb = new ListBuffer<T>();  
 5        lb.add(x);  
 6        return lb;  
 7    }  
 8  
 9    /** The list of elements of this buffer.  
10     */  
11    private List<A> elems;  
12  
13    /** A pointer pointing to the last element of 'elems' containing data,  
14     *  or null if the list is empty.  
15     */  
16    private List<A> last;  
17  
18    /** The number of element in this buffer.  
19     */  
20    private int count;  
21  
22    /** Has a list been created from this buffer yet?  
23     */  
24    private boolean shared;  
25  
26    /** Create a new initially empty list buffer.  
27     */  
28    public ListBuffer() {  
29        clear();  
30    }  
31  
32    /** Append an element to buffer.  
33     */  
34    public ListBuffer<A> append(A x) {  
35        x.getClass(); // null check  
36        if (shared) copy();  
37        List<A> newLast = List.<A>of(x);  
38        if (last != null) {  
39            last.tail = newLast;  
40            last = newLast;  
41        } else {  
42            elems = last = newLast;  
43        }  
44        count++;  
45        return this;  
46    }  
47    ........  
48}

com.sun.tools.javac.util.Names介绍

这个是为我们创建名称的一个工具类，无论是类、方法、参数的名称都需要通过此类来创建。它里面经常被使用到的一个方法就是fromString()，一般使用方法如下所示。

1
2
复制代码1Names names  = new Names()  
2names. fromString("setName");

实战演练

上面我们大概了解了如何操作抽象语法树，接下来我们就来写几个真实的案例加深理解。

变量相关

在类中我们经常操作的参数就是变量，那么如何使用抽象语法树的特性为我们操作变量呢？接下来我们就将一些对于变量的一些操作。

生成变量

例如生成private String age;这样一个变量，借用我们上面讲的VarDef方法

1
2
复制代码1// 生成参数 例如：private String age;  
2treeMaker.VarDef(treeMaker.Modifiers(Flags.PRIVATE), names.fromString("age"), treeMaker.Ident(names.fromString("String")), null);

对变量赋值

例如我们想生成private String name = "BuXueWuShu"，还是利用VarDef方法

1
2
复制代码1// private String name = "BuXueWuShu"  
2treeMaker.VarDef(treeMaker.Modifiers(Flags.PRIVATE),names.fromString("name"),treeMaker.Ident(names.fromString("String")),treeMaker.Literal("BuXueWuShu"))

两个字面量相加

例如我们生成String add = "a" + "b";，借用我们上面讲的Exec方法和Assign方法

1
2
复制代码1// add = "a"+"b"  
2treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("add")),treeMaker.Binary(JCTree.Tag.PLUS,treeMaker.Literal("a"),treeMaker.Literal("b"))))

+=语法

例如我们想生成add += "test"，则和上面字面量差不多。

1
2
复制代码1// add+="test"  
2treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")))

++语法

例如想生成++i

1
复制代码1treeMaker.Exec(treeMaker.Unary(JCTree.Tag.PREINC,treeMaker.Ident(names.fromString("i"))))

方法相关

我们对于变量进行了操作，那么基本上都是要生成方法的，那么如何对方法进行生成和操作呢？我们接下来演示一下关于方法相关的操作方法。

无参无返回值

我们可以利用上面讲到的MethodDef方法进行生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
复制代码 1/*  
 2    无参无返回值的方法生成  
 3    public void test(){  
 4  
 5    }  
 6 */  
 7// 定义方法体  
 8ListBuffer<JCTree.JCStatement> testStatement = new ListBuffer<>();  
 9JCTree.JCBlock testBody = treeMaker.Block(0, testStatement.toList());  
10  
11JCTree.JCMethodDecl test = treeMaker.MethodDef(  
12        treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值  
13        names.fromString("test"), // 方法名  
14        treeMaker.Type(new Type.JCVoidType()), // 返回类型  
15        com.sun.tools.javac.util.List.nil(),  
16        com.sun.tools.javac.util.List.nil(),  
17        com.sun.tools.javac.util.List.nil(),  
18        testBody,    // 方法体  
19        null  
20);

有参无返回值

我们可以利用上面讲到的MethodDef方法进行生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
复制代码 1/*  
 2    无参无返回值的方法生成  
 3    public void test2(String name){  
 4        name = "xxxx";  
 5    }  
 6 */  
 7ListBuffer<JCTree.JCStatement> testStatement2 = new ListBuffer<>();  
 8testStatement2.append(treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("name")),treeMaker.Literal("xxxx"))));  
 9JCTree.JCBlock testBody2 = treeMaker.Block(0, testStatement2.toList());  
10  
11// 生成入参  
12JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);  
13com.sun.tools.javac.util.List<JCTree.JCVariableDecl> parameters = com.sun.tools.javac.util.List.of(param);  
14  
15JCTree.JCMethodDecl test2 = treeMaker.MethodDef(  
16        treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值  
17        names.fromString("test2"), // 方法名  
18        treeMaker.Type(new Type.JCVoidType()), // 返回类型  
19        com.sun.tools.javac.util.List.nil(),  
20        parameters, // 入参  
21        com.sun.tools.javac.util.List.nil(),  
22        testBody2,  
23        null  
24);

有参有返回值

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
复制代码 1 /*  
 2    有参有返回值  
 3    public String test3(String name){  
 4       return name;  
 5    }  
 6 */  
 7  
 8ListBuffer<JCTree.JCStatement> testStatement3 = new ListBuffer<>();  
 9testStatement3.append(treeMaker.Return(treeMaker.Ident(names.fromString("name"))));  
10JCTree.JCBlock testBody3 = treeMaker.Block(0, testStatement3.toList());  
11  
12// 生成入参  
13JCTree.JCVariableDecl param3 = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);  
14com.sun.tools.javac.util.List<JCTree.JCVariableDecl> parameters3 = com.sun.tools.javac.util.List.of(param3);  
15  
16JCTree.JCMethodDecl test3 = treeMaker.MethodDef(  
17        treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值  
18        names.fromString("test4"), // 方法名  
19        treeMaker.Ident(names.fromString("String")), // 返回类型  
20        com.sun.tools.javac.util.List.nil(),  
21        parameters3, // 入参  
22        com.sun.tools.javac.util.List.nil(),  
23        testBody3,  
24        null  
25);

特殊的

我们学完了如何进行定义参数，如何进行定义方法，其实还有好多语句需要学习，例如如何生成new语句，如何生成方法调用的语句，如何生成if语句。j接下来我们就学习一些比较特殊的语法。

new一个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
复制代码 1// 创建一个new语句 CombatJCTreeMain combatJCTreeMain = new CombatJCTreeMain();  
 2JCTree.JCNewClass combatJCTreeMain = treeMaker.NewClass(  
 3        null,  
 4        com.sun.tools.javac.util.List.nil(),  
 5        treeMaker.Ident(names.fromString("CombatJCTreeMain")),  
 6        com.sun.tools.javac.util.List.nil(),  
 7        null  
 8);  
 9JCTree.JCVariableDecl jcVariableDecl1 = treeMaker.VarDef(  
10        treeMaker.Modifiers(Flags.PARAMETER),  
11        names.fromString("combatJCTreeMain"),  
12        treeMaker.Ident(names.fromString("CombatJCTreeMain")),  
13        combatJCTreeMain  
14);

方法调用（无参）

1
2
3
4
5
6
7
8
9
10
复制代码 1JCTree.JCExpressionStatement exec = treeMaker.Exec(  
 2        treeMaker.Apply(  
 3                com.sun.tools.javac.util.List.nil(),  
 4                treeMaker.Select(  
 5                        treeMaker.Ident(names.fromString("combatJCTreeMain")), // . 左边的内容  
 6                        names.fromString("test") // . 右边的内容  
 7                ),  
 8                com.sun.tools.javac.util.List.nil()  
 9        )  
10);

方法调用（有参）

1
2
3
4
5
6
7
8
9
10
11
复制代码 1// 创建一个方法调用 combatJCTreeMain.test2("hello world!");  
 2JCTree.JCExpressionStatement exec2 = treeMaker.Exec(  
 3        treeMaker.Apply(  
 4                com.sun.tools.javac.util.List.nil(),  
 5                treeMaker.Select(  
 6                        treeMaker.Ident(names.fromString("combatJCTreeMain")), // . 左边的内容  
 7                        names.fromString("test2") // . 右边的内容  
 8                ),  
 9                com.sun.tools.javac.util.List.of(treeMaker.Literal("hello world!")) // 方法中的内容  
10        )  
11);

if语句

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
复制代码 1/*  
 2    创建一个if语句  
 3    if("BuXueWuShu".equals(name)){  
 4        add = "a" + "b";  
 5    }else{  
 6        add += "test";  
 7    }  
 8 */  
 9// "BuXueWuShu".equals(name)  
10JCTree.JCMethodInvocation apply = treeMaker.Apply(  
11        com.sun.tools.javac.util.List.nil(),  
12        treeMaker.Select(  
13                treeMaker.Literal("BuXueWuShu"), // . 左边的内容  
14                names.fromString("equals") // . 右边的内容  
15        ),  
16        com.sun.tools.javac.util.List.of(treeMaker.Ident(names.fromString("name")))  
17);  
18//  add = "a" + "b"  
19JCTree.JCExpressionStatement exec3 = treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("add")), treeMaker.Binary(JCTree.Tag.PLUS, treeMaker.Literal("a"), treeMaker.Literal("b"))));  
20//  add += "test"  
21JCTree.JCExpressionStatement exec1 = treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")));  
22  
23JCTree.JCIf anIf = treeMaker.If(  
24        apply, // if语句里面的判断语句  
25        exec3, // 条件成立的语句  
26        exec1  // 条件不成立的语句  
27);

源码地址

总结

纸上得来终觉浅，绝知此事要躬行。希望大家看完此篇文章能够自己在本机上自己试验一下。自己设置几个参数，自己学的Lombok学着生成一下get、set方法，虽然本篇知识在日常开发中基本上不会用到，但是万一用到了这些知识那么别人不会而你会，差距其实就慢慢的给拉开了。本篇涉及到的所有代码都在github上面有，拉下来以后全局搜CombatJCTreeProcessor类就可以看到了。

有感兴趣的可以关注一下我新建的公众号，搜索[程序猿的百宝袋]。或者直接扫下面的码也行。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%