《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 my.oschina.net/u/4030990/blog/3211858 「不学无数的程序员」欢迎转载,保留摘要,谢谢!


🙂🙂🙂关注微信公众号:【芋道源码】有福利:

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言将得到认真回复。甚至不知道如何读源码也可以请教噢
  4. 新的源码解析文章实时收到通知。每周更新一篇左右
  5. 认真的源码交流微信群。

在网上关于如何修改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:声明语法树节点,常见的子类如下

2.

    • JCBlock:语句块语法树节点
  • JCReturn:return语句语法树节点
  • JCClassDecl:类定义语法树节点
  • JCVariableDecl:字段/变量定义语法树节点
  1. JCMethodDecl:方法定义语法树节点

  2. JCModifiers:访问标志语法树节点

  3. JCExpression:表达式语法树节点,常见的子类如下

7.

    • 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<JCAnnotation> 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<JCTypeParameter> typarams,
JCExpression extending,
List<JCExpression> implementing,
List<JCTree> 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<JCTypeParameter> typarams,
List<JCVariableDecl> params,
List<JCExpression> 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<JCExpression> typeargs,
JCExpression clazz,
List<JCExpression> 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<JCExpression> typeargs,
JCExpression fn,
List<JCExpression> 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<JCStatement> 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<A> tail;
private static final List<?> EMPTY_LIST = new List<Object>((Object)null, (List)null) {
public List<Object> setTail(List<Object> var1) {
throw new UnsupportedOperationException();
}

public boolean isEmpty() {
return true;
}
};

List(A head, List<A> tail) {
this.tail = tail;
this.head = head;
}

public static <A> List<A> nil() {
return EMPTY_LIST;
}

public List<A> prepend(A var1) {
return new List(var1, this);
}

public List<A> append(A var1) {
return of(var1).prependList(this);
}

public static <A> List<A> of(A var0) {
return new List(var0, nil());
}

public static <A> List<A> of(A var0, A var1) {
return new List(var0, of(var1));
}

public static <A> List<A> of(A var0, A var1, A var2) {
return new List(var0, of(var1, var2));
}

public static <A> List<A> 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 <T> ListBuffer<T> of(T x) {
ListBuffer<T> lb = new ListBuffer<T>();
lb.add(x);
return lb;
}

/** The list of elements of this buffer.
*/
private List<A> elems;

/** A pointer pointing to the last element of 'elems' containing data,
* or null if the list is empty.
*/
private List<A> 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<A> append(A x) {
x.getClass(); // null check
if (shared) copy();
List<A> newLast = List.<A>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 age;
treeMaker.VarDef(treeMaker.Modifiers(Flags.PRIVATE), names.fromString("age"), treeMaker.Ident(names.fromString("String")), null);

对变量赋值

例如我们想生成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<JCTree.JCStatement> 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<JCTree.JCStatement> 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<JCTree.JCVariableDecl> 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<JCTree.JCStatement> 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<JCTree.JCVariableDecl> 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类就可以看到了。

文章目录
  1. 1. JCTree的介绍
  2. 2. TreeMaker介绍
    1. 2.1. TreeMaker.Modifiers
    2. 2.2. TreeMaker.ClassDef
    3. 2.3. TreeMaker.MethodDef
    4. 2.4. TreeMaker.VarDef
    5. 2.5. TreeMaker.Ident
    6. 2.6. TreeMaker.Return
    7. 2.7. TreeMaker.Select
    8. 2.8. TreeMaker.NewClass
    9. 2.9. TreeMaker.Apply
    10. 2.10. TreeMaker.Assign
    11. 2.11. TreeMaker.Exec
    12. 2.12. TreeMaker.Block
  3. 3. com.sun.tools.javac.util.List介绍
  4. 4. com.sun.tools.javac.util.ListBuffer
  5. 5. com.sun.tools.javac.util.Names介绍
  6. 6. 实战演练
    1. 6.1. 变量相关
      1. 6.1.1. 生成变量
      2. 6.1.2. 对变量赋值
      3. 6.1.3. 两个字面量相加
      4. 6.1.4. +=语法
      5. 6.1.5. ++语法
    2. 6.2. 方法相关
      1. 6.2.1. 无参无返回值
      2. 6.2.2. 有参无返回值
      3. 6.2.3. 有参有返回值
    3. 6.3. 特殊的
      1. 6.3.1. new一个对象
      2. 6.3.2. 方法调用(无参)
      3. 6.3.3. 方法调用(有参)
      4. 6.3.4. if语句
  7. 7. 总结