作者：不學無數的程式設計師

來源：[https://my.oschina.net/u/4030990/blog/3211858](https://my.oschina.net/u/4030990/blog/3211858)

在網上關於如何修改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<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 rel="nofollow"> extends AbstractCollection</a><a rel="nofollow"> implements java.util.List</a><a rel="nofollow"> {
    public A head;
    public List</a><a rel="nofollow"> 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 rel="nofollow"> tail) {
        this.tail = tail;
        this.head = head;
    }

public static </a><a rel="nofollow"> List</a><a rel="nofollow"> nil() {
        return EMPTY_LIST;
    }

public List</a><a rel="nofollow"> prepend(A var1) {
        return new List(var1, this);
    }

public List</a><a rel="nofollow"> append(A var1) {
        return of(var1).prependList(this);
    }

public static </a><a rel="nofollow"> List</a><a rel="nofollow"> of(A var0) {
        return new List(var0, nil());
    }

public static </a><a rel="nofollow"> List</a><a rel="nofollow"> of(A var0, A var1) {
        return new List(var0, of(var1));
    }

public static </a><a rel="nofollow"> List</a><a rel="nofollow"> of(A var0, A var1, A var2) {
        return new List(var0, of(var1, var2));
    }

public static </a><a rel="nofollow"> List</a><a rel="nofollow"> 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><a rel="nofollow"> extends AbstractQueue</a><a rel="nofollow"> {

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 rel="nofollow"> elems;

/** A pointer pointing to the last element of 'elems' containing data,
     *  or null if the list is empty.
     */
    private List</a><a rel="nofollow"> 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><a rel="nofollow"> append(A x) {
        x.getClass(); // null check
        if (shared) copy();
        List</a><a rel="nofollow"> newLast = List.</a><a rel="nofollow">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](https://github.com/modouxiansheng/Doraemon)

## 總結

紙上得來終覺淺，絕知此事要躬行。

希望大家看完此篇文章能夠自己在本機上自己試驗一下。

自己設定幾個引數，自己學的Lombok學著生成一下get、set方法，雖然本篇知識在日常開發中基本上不會用到，但是萬一用到了這些知識那麼別人不會而你會，差距其實就慢慢的給拉開了。

本篇涉及到的所有程式碼都在github上面有，拉下來以後全域性搜`CombatJCTreeProcessor`類就可以看到了。</jctree.jcvariabledecl></jctree.jcstatement></jctree.jcvariabledecl></jctree.jcstatement></jctree.jcstatement></a></t></t></t></t></a></object></object></object></a></jcstatement></jcexpression></jcexpression></jcexpression></jcexpression></jcexpression></jcvariabledecl></jctypeparameter></jctree></jcexpression></jctypeparameter></jcannotation>

Java 中的屠龍之術：如何修改語法樹？

相關文章