Java 抽象语法术 JCTree 介绍和使用

泥瓦匠BYSocket

共 7615字,需浏览 16分钟

 ·

2021-11-16 00:07

不点蓝字关注,我们哪来故事?




正文如下

作者:不学无数的程序员

链接:https://www.jianshu.com/p/6d3c208faca8


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


# JCTree的介绍


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

public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
public int pos = -1;
...
public abstract void accept(JCTree.Visitor visitor);
...}

我们可以看到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),源码如下

public JCModifiers Modifiers(long flags) {    return Modifiers(flags, List.< JCAnnotation >nil());}
public JCModifiers Modifiers(long flags, List annotations) { JCModifiers tree = new JCModifiers(flags, annotations); boolean noFlags = (flags & (Flags.ModifierFlags | Flags.ANNOTATION)) == 0; tree.pos = (noFlags && annotations.isEmpty()) ? Position.NOPOS : pos; return tree;}

  1. flags:访问标志

  2. annotations:注解列表


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

treeMaker.Modifiers(Flags.PUBLIC + Flags.STATIC + Flags.FINAL);
public static final

# TreeMaker.ClassDef


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

public JCClassDecl ClassDef(JCModifiers mods,    Name name,    List typarams,    JCExpression extending,    List implementing,    List defs) {        JCClassDecl tree = new JCClassDecl(mods,                                     name,                                     typarams,                                     extending,                                     implementing,                                     defs,                                     null);        tree.pos = pos;        return tree;}


  1. mods:访问标志,可以通过TreeMaker.Modifiers来创建

  2. name:类名

  3. typarams:泛型参数列表

  4. extending:父类

  5. implementing:实现的接口

  6. defs:类定义的详细语句,包括字段、方法的定义等等


# TreeMaker.MethodDef


TreeMaker.MethodDef用于创建方法定义语法树节点(JCMethodDecl),源码如下

public JCMethodDecl MethodDef(JCModifiers mods,    Name name,    JCExpression restype,    List typarams,    List params,    List thrown,    JCBlock body,    JCExpression defaultValue) {        JCMethodDecl tree = new JCMethodDecl(mods,                                       name,                                       restype,                                       typarams,                                       params,                                       thrown,                                       body,                                       defaultValue,                                       null);        tree.pos = pos;        return tree;}
public JCMethodDecl MethodDef(MethodSymbol m, Type mtype, JCBlock body) { return (JCMethodDecl) new JCMethodDecl( Modifiers(m.flags(), Annotations(m.getAnnotationMirrors())), m.name, Type(mtype.getReturnType()), TypeParams(mtype.getTypeArguments()), Params(mtype.getParameterTypes(), m), Types(mtype.getThrownTypes()), body, null, m).setPos(pos).setType(mtype);}

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

public JCVariableDecl VarDef(JCModifiers mods,    Name name,    JCExpression vartype,    JCExpression init) {        JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);        tree.pos = pos;        return tree;}
public JCVariableDecl VarDef(VarSymbol v, JCExpression init) { return (JCVariableDecl) new JCVariableDecl( Modifiers(v.flags(), Annotations(v.getAnnotationMirrors())), v.name, Type(v.type), init, v).setPos(pos).setType(v.type);}

  1. mods:访问标志

  2. name:参数名称

  3. vartype:类型

  4. init:初始化语句

  5. v:变量符号


# TreeMaker.Ident


TreeMaker.Ident用于创建标识符语法树节点(JCIdent),源码如下

public JCIdent Ident(Name name) {        JCIdent tree = new JCIdent(name, null);        tree.pos = pos;        return tree;}
public JCIdent Ident(Symbol sym) { return (JCIdent)new JCIdent((sym.name != names.empty) ? sym.name : sym.flatName(), sym) .setPos(pos) .setType(sym.type);}
public JCExpression Ident(JCVariableDecl param) { return Ident(param.sym);}

# TreeMaker.Return


TreeMaker.Return用于创建return语句(JCReturn),源码如下

public JCReturn Return(JCExpression expr) {        JCReturn tree = new JCReturn(expr);        tree.pos = pos;        return tree;}


# TreeMaker.Select


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

public JCFieldAccess Select(JCExpression selected,    Name selector) {        JCFieldAccess tree = new JCFieldAccess(selected, selector, null);        tree.pos = pos;        return tree;}
public JCExpression Select(JCExpression base, Symbol sym) { return new JCFieldAccess(base, sym.name, sym).setPos(pos).setType(sym.type);}

  1. selected:.运算符左边的表达式

  2. selector:.运算符右边的表达式


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

一. TreeMaker.Select(treeMaker.Ident(names.fromString("this")), names.fromString("name"));
二. this.name

# TreeMaker.NewClass


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

public JCNewClass NewClass(JCExpression encl,    List typeargs,    JCExpression clazz,    List args,    JCClassDecl def) {        JCNewClass tree = new JCNewClass(encl, typeargs, clazz, args, def);        tree.pos = pos;        return tree;}

  1. encl:不太明白此参数的含义,我看很多例子中此参数都设置为null

  2. typeargs:参数类型列表

  3. clazz:待创建对象的类型

  4. args:参数列表

  5. def:类定义


# TreeMaker.Apply


TreeMaker.Apply用于创建方法调用语法树节点(JCMethodInvocation),源码如下:

public JCMethodInvocation Apply(List typeargs,    JCExpression fn,    List args) {        JCMethodInvocation tree = new JCMethodInvocation(typeargs, fn, args);        tree.pos = pos;        return tree;}

  1. typeargs:参数类型列表

  2. fn:调用语句

  3. args:参数列表


# TreeMaker.Assign


TreeMaker.Assign用户创建赋值语句语法树节点(JCAssign),源码如下:

ublic JCAssign Assign(JCExpression lhs,    JCExpression rhs) {        JCAssign tree = new JCAssign(lhs, rhs);        tree.pos = pos;        return tree;}

  1. lhs:赋值语句左边表达式

  2. rhs:赋值语句右边表达式


# TreeMaker.Exec


TreeMaker.Exec用于创建可执行语句语法树节点(JCExpressionStatement),源码如下:

public JCExpressionStatement Exec(JCExpression expr) {        JCExpressionStatement tree = new JCExpressionStatement(expr);        tree.pos = pos;        return tree;}

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


# TreeMaker.Block


TreeMaker.Block用于创建组合语句的语法树节点(JCBlock),源码如下:

public JCBlock Block(long flags,    List stats) {        JCBlock tree = new JCBlock(flags, stats);        tree.pos = pos;        return tree;}

  1. flags:访问标志

  2. stats:语句列表


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


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

public class List<A> extends AbstractCollection<A> implements java.util.List<A> {    public A head;    public List tail;    private static final List> EMPTY_LIST = new List((Object)null, (List)null) {        public List setTail(List var1) {            throw new UnsupportedOperationException();        }
public boolean isEmpty() { return true; } };
List(A head, List tail) { this.tail = tail; this.head = head; }
public static
List nil() { return EMPTY_LIST; }
public List
prepend(A var1) { return new List(var1, this); }
public List
append(A var1) { return of(var1).prependList(this); }
public static
List of(A var0) { return new List(var0, nil()); }
public static
List of(A var0, A var1) { return new List(var0, of(var1)); }
public static
List of(A var0, A var1, A var2) { return new List(var0, of(var1, var2)); }
public static
List of(A var0, A var1, A var2, A... var3) { return new List(var0, new List(var1, new List(var2, from(var3)))); }
...}

# com.sun.tools.javac.util.ListBuffer


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

public class ListBuffer<A> extends AbstractQueue<A> {
public static ListBuffer of(T x) { ListBuffer lb = new ListBuffer(); lb.add(x); return lb; }
/** The list of elements of this buffer. */ private List
elems;
/** A pointer pointing to the last element of 'elems' containing data, * or null if the list is empty. */ private List
last;
/** The number of element in this buffer. */ private int count;
/** Has a list been created from this buffer yet? */ private boolean shared;
/** Create a new initially empty list buffer. */ public ListBuffer() { clear(); }
/** Append an element to buffer. */ public ListBuffer
append(A x) { x.getClass(); // null check if (shared) copy(); List newLast = List.of(x); if (last != null) { last.tail = newLast; last = newLast; } else { elems = last = newLast; } count++; return this; } ........}

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


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

Names names  = new Names()names. fromString("setName");

# 实战演练


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


# 变量相关


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


# 生成变量


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



# 对变量赋值


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

// private String name = "BuXueWuShu"treeMaker.VarDef(treeMaker.Modifiers(Flags.PRIVATE),names.fromString("name"),treeMaker.Ident(names.fromString("String")),treeMaker.Literal("BuXueWuShu"))

# 两个字面量相加


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

// add = "a"+"b"treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("add")),treeMaker.Binary(JCTree.Tag.PLUS,treeMaker.Literal("a"),treeMaker.Literal("b"))))

# +=语法


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

// add+="test"treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")))

# ++语法

例如想生成++i

treeMaker.Exec(treeMaker.Unary(JCTree.Tag.PREINC,treeMaker.Ident(names.fromString("i"))))

# 方法相关


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


# 无参无返回值


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

/*    无参无返回值的方法生成    public void test(){
} */// 定义方法体ListBuffer testStatement = new ListBuffer<>();JCTree.JCBlock testBody = treeMaker.Block(0, testStatement.toList()); JCTree.JCMethodDecl test = treeMaker.MethodDef( treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值 names.fromString("test"), // 方法名 treeMaker.Type(new Type.JCVoidType()), // 返回类型 com.sun.tools.javac.util.List.nil(), com.sun.tools.javac.util.List.nil(), com.sun.tools.javac.util.List.nil(), testBody, // 方法体 null);

# 有参无返回值


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

/*    无参无返回值的方法生成    public void test2(String name){        name = "xxxx";    } */ListBuffer testStatement2 = new ListBuffer<>();testStatement2.append(treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("name")),treeMaker.Literal("xxxx"))));JCTree.JCBlock testBody2 = treeMaker.Block(0, testStatement2.toList());
// 生成入参JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);com.sun.tools.javac.util.List parameters = com.sun.tools.javac.util.List.of(param);
JCTree.JCMethodDecl test2 = treeMaker.MethodDef( treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值 names.fromString("test2"), // 方法名 treeMaker.Type(new Type.JCVoidType()), // 返回类型 com.sun.tools.javac.util.List.nil(), parameters, // 入参 com.sun.tools.javac.util.List.nil(), testBody2, null);

# 有参有返回值

 /*    有参有返回值    public String test3(String name){       return name;    } */
ListBuffer testStatement3 = new ListBuffer<>();testStatement3.append(treeMaker.Return(treeMaker.Ident(names.fromString("name"))));JCTree.JCBlock testBody3 = treeMaker.Block(0, testStatement3.toList());
// 生成入参JCTree.JCVariableDecl param3 = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);com.sun.tools.javac.util.List parameters3 = com.sun.tools.javac.util.List.of(param3);
JCTree.JCMethodDecl test3 = treeMaker.MethodDef( treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值 names.fromString("test4"), // 方法名 treeMaker.Ident(names.fromString("String")), // 返回类型 com.sun.tools.javac.util.List.nil(), parameters3, // 入参 com.sun.tools.javac.util.List.nil(), testBody3, null);

# 特殊的


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


# new一个对象

// 创建一个new语句 CombatJCTreeMain combatJCTreeMain = new CombatJCTreeMain();JCTree.JCNewClass combatJCTreeMain = treeMaker.NewClass(        null,        com.sun.tools.javac.util.List.nil(),        treeMaker.Ident(names.fromString("CombatJCTreeMain")),        com.sun.tools.javac.util.List.nil(),        null);JCTree.JCVariableDecl jcVariableDecl1 = treeMaker.VarDef(        treeMaker.Modifiers(Flags.PARAMETER),        names.fromString("combatJCTreeMain"),        treeMaker.Ident(names.fromString("CombatJCTreeMain")),        combatJCTreeMain);

# 方法调用(无参)

JCTree.JCExpressionStatement exec = treeMaker.Exec(        treeMaker.Apply(                com.sun.tools.javac.util.List.nil(),                treeMaker.Select(                        treeMaker.Ident(names.fromString("combatJCTreeMain")), // . 左边的内容                        names.fromString("test") // . 右边的内容                ),                com.sun.tools.javac.util.List.nil()        ));

# 方法调用(有参)

// 创建一个方法调用 combatJCTreeMain.test2("hello world!");JCTree.JCExpressionStatement exec2 = treeMaker.Exec(        treeMaker.Apply(                com.sun.tools.javac.util.List.nil(),                treeMaker.Select(                        treeMaker.Ident(names.fromString("combatJCTreeMain")), // . 左边的内容                        names.fromString("test2") // . 右边的内容                ),                com.sun.tools.javac.util.List.of(treeMaker.Literal("hello world!")) // 方法中的内容        ));

# if语句

/*    创建一个if语句    if("BuXueWuShu".equals(name)){        add = "a" + "b";    }else{        add += "test";    } */// "BuXueWuShu".equals(name)JCTree.JCMethodInvocation apply = treeMaker.Apply(        com.sun.tools.javac.util.List.nil(),        treeMaker.Select(                treeMaker.Literal("BuXueWuShu"), // . 左边的内容                names.fromString("equals") // . 右边的内容        ),        com.sun.tools.javac.util.List.of(treeMaker.Ident(names.fromString("name"))));//  add = "a" + "b"JCTree.JCExpressionStatement exec3 = treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("add")), treeMaker.Binary(JCTree.Tag.PLUS, treeMaker.Literal("a"), treeMaker.Literal("b"))));//  add += "test"JCTree.JCExpressionStatement exec1 = treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")));
JCTree.JCIf anIf = treeMaker.If( apply, // if语句里面的判断语句 exec3, // 条件成立的语句 exec1 // 条件不成立的语句);

源码地址:https://github.com/modouxiansheng/Doraemon


# 总结


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


往期推荐

一女程序员被判 9 个月:因薪酬等问题离职,rm -f  删库,瘫痪 6 个小时

比Visio快10倍的画图工具来了!赶紧整上~

Spring Boot 异步调用的示例

IDEA Live Templates 用法

打日志的一些手法和习惯


-END-

↑ 点击上方关注我公号  


我是 泥瓦匠,坚持分享编程,算法,Java 等干货教程


一枚医科大本科生,开源小作者,半吊子创业爱好者...

半吊子的自己在试错,不知道以后会干什么,但享受现在的试错,试错给我惊讶的生活


喜欢公号的互动分享,感谢关注,路上遇见了你,同一小段时间之路,相伴 ~



长按识别,加我微信

浏览 56
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报