Java

JCTree的介绍

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

  1. public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
  3.     public int pos = -1;
  5.     ...
  7.     public abstract void accept(JCTree.Visitor visitor);
  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），源码如下 ```java 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; }

  2. 1. flags：访问标志
  3. 1. annotations：注解列表
  5. 其中`flags`可以使用枚举类`com.sun.tools.javac.code.Flags`来表示，例如可以这样用，就生成了下面的访问标志了。
  6. ```java
  7. treeMaker.Modifiers(Flags.PUBLIC + Flags.STATIC + Flags.FINAL);
  9. public static final

TreeMaker.ClassDef

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

  1. public 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），源码如下 ```java public JCMethodDecl MethodDef(JCModifiers mods, Name name, JCExpression restype, List typarams, List params, List thrown, JCBlock body, JCExpression defaultValue) {
    1.  JCMethodDecl tree = new JCMethodDecl(mods,
    2.                                 name,
    3.                                 restype,
    4.                                 typarams,
    5.                                 params,
    6.                                 thrown,
    7.                                 body,
    8.                                 defaultValue,
    9.                                 null);
    10.  tree.pos = pos;
    11.  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); }

  2. 1. mods：访问标志
  3. 1. name：方法名
  4. 1. restype：返回类型
  5. 1. typarams：泛型参数列表
  6. 1. params：参数列表
  7. 1. thrown：异常声明列表
  8. 1. body：方法体
  9. 1. defaultValue：默认方法（可能是interface中的哪个default）
  10. 1. m：方法符号
  11. 1. mtype：方法类型。包含多种类型，泛型参数类型、方法参数类型、异常参数类型、返回参数类型。
  13. 返回类型`restype`填写null或者`treeMaker.TypeIdent(TypeTag.VOID)`都代表返回void类型。
  14. <a name="OAvHm"></a>
  15. ### `TreeMaker.VarDef`
  16. `TreeMaker.VarDef`用于创建字段/变量定义语法树节点（`JCVariableDecl`），源码如下
  17. ```java
  18. public JCVariableDecl VarDef(JCModifiers mods,
  19.     Name name,
  20.     JCExpression vartype,
  21.     JCExpression init) {
  22.         JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);
  23.         tree.pos = pos;
  24.         return tree;
  25. }
  27. public JCVariableDecl VarDef(VarSymbol v,
  28.     JCExpression init) {
  29.         return (JCVariableDecl)
  30.             new JCVariableDecl(
  31.                 Modifiers(v.flags(), Annotations(v.getAnnotationMirrors())),
  32.                 v.name,
  33.                 Type(v.type),
  34.                 init,
  35.                 v).setPos(pos).setType(v.type);
  36. }
  1. mods：访问标志
  2. name：参数名称
  3. vartype：类型
  4. init：初始化语句
  5. v：变量符号

    TreeMaker.Ident

    TreeMaker.Ident用于创建标识符语法树节点（JCIdent），源码如下 ```java public JCIdent Ident(Name name) {
    1.  JCIdent tree = new JCIdent(name, null);
    2.  tree.pos = pos;
    3.  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); }

  1. <a name="GBBZB"></a>
  2. ### `TreeMaker.Return`
  3. `TreeMaker.Return`用于创建`return`语句（`JCReturn`），源码如下
  4. ```java
  5. public JCReturn Return(JCExpression expr) {
  6.         JCReturn tree = new JCReturn(expr);
  7.         tree.pos = pos;
  8.         return tree;
  9. }

TreeMaker.Select

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

  1. public JCFieldAccess Select(JCExpression selected,
  2.     Name selector) 
  3. {
  4.         JCFieldAccess tree = new JCFieldAccess(selected, selector, null);
  5.         tree.pos = pos;
  6.         return tree;
  7. }
  9. public 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语句就是二语句
一. TreeMaker.Select(treeMaker.Ident(names.fromString("this")), names.fromString("name"));
二. this.name

TreeMaker.NewClass

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

  1. public 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. public 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. }

  6. typeargs：参数类型列表

  7. fn：调用语句

  8. args：参数列表

    TreeMaker.Assign

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

    1. ublic JCAssign Assign(JCExpression lhs,
    2.  JCExpression rhs) {
    3.      JCAssign tree = new JCAssign(lhs, rhs);
    4.      tree.pos = pos;
    5.      return tree;
    6. }

  9. lhs：赋值语句左边表达式

  10. rhs：赋值语句右边表达式

    TreeMaker.Exec

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

    1. public 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. public JCBlock Block(long flags,
    2.  List<JCStatement> stats) {
    3.      JCBlock tree = new JCBlock(flags, stats);
    4.      tree.pos = pos;
    5.      return tree;
    6. }

  11. flags：访问标志

  12. stats：语句列表

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

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

    1. public 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.      }
    9.      public boolean isEmpty() {
    10.          return true;
    11.      }
    12.  };
    14.  List(A head, List<A> tail) {
    15.      this.tail = tail;
    16.      this.head = head;
    17.  }
    19.  public static <A> List<A> nil() {
    20.      return EMPTY_LIST;
    21.  }
    23.  public List<A> prepend(A var1) {
    24.      return new List(var1, this);
    25.  }
    27.  public List<A> append(A var1) {
    28.      return of(var1).prependList(this);
    29.  }
    31.  public static <A> List<A> of(A var0) {
    32.      return new List(var0, nil());
    33.  }
    35.  public static <A> List<A> of(A var0, A var1) {
    36.      return new List(var0, of(var1));
    37.  }
    39.  public static <A> List<A> of(A var0, A var1, A var2) {
    40.      return new List(var0, of(var1, var2));
    41.  }
    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.  }
    47.  ...
    48. }

    com.sun.tools.javac.util.ListBuffer

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

    1. public class ListBuffer<A> extends AbstractQueue<A> {
    3.  public static <T> ListBuffer<T> of(T x) {
    4.      ListBuffer<T> lb = new ListBuffer<T>();
    5.      lb.add(x);
    6.      return lb;
    7.  }
    9.  /** The list of elements of this buffer.
    10.   */
    11.  private List<A> elems;
    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;
    18.  /** The number of element in this buffer.
    19.   */
    20.  private int count;
    22.  /** Has a list been created from this buffer yet?
    23.   */
    24.  private boolean shared;
    26.  /** Create a new initially empty list buffer.
    27.   */
    28.  public ListBuffer() {
    29.      clear();
    30.  }
    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. Names names  = new Names()
    2. names. fromString("setName");

    实战演练

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

    变量相关

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

    生成变量

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

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

    对变量赋值

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

    1. // private String name = "BuXueWuShu"
    2. treeMaker.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"
    2. treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("add")),treeMaker.Binary(JCTree.Tag.PLUS,treeMaker.Literal("a"),treeMaker.Literal("b"))))

    +=语法

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

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

    ++语法

    例如想生成++i

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

    方法相关

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

    无参无返回值

    可以利用上面讲到的MethodDef方法进行生成 ```java /* 无参无返回值的方法生成 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 );

  1. <a name="KSlkK"></a>
  2. #### 有参无返回值
  3. 可以利用上面讲到的`MethodDef`方法进行生成
  4. ```java
  5. /*
  6.     无参无返回值的方法生成
  7.     public void test2(String name){
  8.         name = "xxxx";
  9.     }
  10.  */
  11. ListBuffer<JCTree.JCStatement> testStatement2 = new ListBuffer<>();
  12. testStatement2.append(treeMaker.Exec(treeMaker.Assign(treeMaker.Ident(names.fromString("name")),treeMaker.Literal("xxxx"))));
  13. JCTree.JCBlock testBody2 = treeMaker.Block(0, testStatement2.toList());
  15. // 生成入参
  16. JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);
  17. com.sun.tools.javac.util.List<JCTree.JCVariableDecl> parameters = com.sun.tools.javac.util.List.of(param);
  19. JCTree.JCMethodDecl test2 = treeMaker.MethodDef(
  20.         treeMaker.Modifiers(Flags.PUBLIC), // 方法限定值
  21.         names.fromString("test2"), // 方法名
  22.         treeMaker.Type(new Type.JCVoidType()), // 返回类型
  23.         com.sun.tools.javac.util.List.nil(),
  24.         parameters, // 入参
  25.         com.sun.tools.javac.util.List.nil(),
  26.         testBody2,
  27.         null
  28. );

有参有返回值

  1.  /*
  2.     有参有返回值
  3.     public String test3(String name){
  4.        return name;
  5.     }
  6.  */
  8. ListBuffer<JCTree.JCStatement> testStatement3 = new ListBuffer<>();
  9. testStatement3.append(treeMaker.Return(treeMaker.Ident(names.fromString("name"))));
  10. JCTree.JCBlock testBody3 = treeMaker.Block(0, testStatement3.toList());
  12. // 生成入参
  13. JCTree.JCVariableDecl param3 = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER), names.fromString("name"),treeMaker.Ident(names.fromString("String")), null);
  14. com.sun.tools.javac.util.List<JCTree.JCVariableDecl> parameters3 = com.sun.tools.javac.util.List.of(param3);
  16. JCTree.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语句。接下来就学习一些比较特殊的语法。

new一个对象

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

方法调用（无参）

  1. JCTree.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!");
  2. JCTree.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)
  10. JCTree.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"
  19. JCTree.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"
  21. JCTree.JCExpressionStatement exec1 = treeMaker.Exec(treeMaker.Assignop(JCTree.Tag.PLUS_ASG, treeMaker.Ident(names.fromString("add")), treeMaker.Literal("test")));
  23. JCTree.JCIf anIf = treeMaker.If(
  24.         apply, // if语句里面的判断语句
  25.         exec3, // 条件成立的语句
  26.         exec1  // 条件不成立的语句
  27. );