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

·  阅读 3518
Java中的屠龙之术——如何修改语法树

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

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

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

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

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

JCTree的介绍

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

 1public abstract class JCTree implements TreeCloneableDiagnosticPosition {
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),源码如下

 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来表示,例如我们可以这样用,就生成了下面的访问标志了。

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

TreeMaker.ClassDef

TreeMaker.ClassDef用于创建类定义语法树节点(JCClassDecl),源码如下:

 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),源码如下

 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),源码如下

 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),源码如下

 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),源码如下

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),源码如下

 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一. TreeMaker.Select(treeMaker.Ident(names.fromString("this")), names.fromString("name"));
2
3二. this.name
复制代码

TreeMaker.NewClass

TreeMaker.NewClass用于创建new语句语法树节点(JCNewClass),源码如下:

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),源码如下:

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),源码如下:

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),源码如下:

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),源码如下:

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,这里作为了解就行了。

 1public class List<Aextends AbstractCollection<Aimplements 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用法非常类似。

 1public class ListBuffer<Aextends 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(),一般使用方法如下所示。

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

实战演练

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

变量相关

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

生成变量

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

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// 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// 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// add+="test"
2treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")))
复制代码

++语法

例如想生成++i

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

方法相关

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

无参无返回值

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

 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    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    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// 创建一个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);
复制代码

方法调用(无参)

 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// 创建一个方法调用 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    创建一个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类就可以看到了。

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

分类:
后端
标签:
分类:
后端
标签: