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

电玩女神 2022-09-14 08:55 144阅读 0赞

**点击关注公众号，Java干货****及时送达**![2876d0ab658c265911c3eea3b2a7d930.png][]

作者：不学无数的程序员  
来源：https://my.oschina.net/u/4030990/blog/3211858

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

## **JCTree的介绍** ##

[JCTree是语法树元素的基类，包含一个重要的字段pos，该字段用于指明当前语法树节点（JCTree）在语法树中的位置，因此我们不能直接用new关键字来创建语法树节点，即使创建了也没有意义。][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：**声明**语法树节点，常见的子类如下][JCTree_pos_JCTree_new]

*  [JCBlock：**语句块**语法树节点][JCTree_pos_JCTree_new]
 *  [JCReturn：**return语句**语法树节点][JCTree_pos_JCTree_new]
 *  [JCClassDecl：**类定义**语法树节点][JCTree_pos_JCTree_new]
 *  [JCVariableDecl：**字段/变量定义**语法树节点][JCTree_pos_JCTree_new]

[JCMethodDecl：**方法定义**语法树节点][JCTree_pos_JCTree_new]

[JCModifiers：**访问标志**语法树节点][JCTree_pos_JCTree_new]

[JCExpression：**表达式**语法树节点，常见的子类如下][JCTree_pos_JCTree_new]

*  [JCAssign：**赋值语句**语法树节点][JCTree_pos_JCTree_new]
 *  [JCIdent：**标识符**语法树节点，可以是变量，类型，关键字等等][JCTree_pos_JCTree_new]

## 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），源码如下][JCTree_pos_JCTree_new]

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：访问标志][JCTree_pos_JCTree_new]
2.  [name：方法名][JCTree_pos_JCTree_new]
3.  [restype：返回类型][JCTree_pos_JCTree_new]
4.  [typarams：泛型参数列表][JCTree_pos_JCTree_new]
5.  [params：参数列表][JCTree_pos_JCTree_new]
6.  [thrown：异常声明列表][JCTree_pos_JCTree_new]
7.  [body：方法体][JCTree_pos_JCTree_new]
8.  [defaultValue：默认方法（可能是interface中的哪个default）][JCTree_pos_JCTree_new]
9.  [m：方法符号][JCTree_pos_JCTree_new]
10. [mtype：方法类型。包含多种类型，泛型参数类型、方法参数类型、异常参数类型、返回参数类型。][JCTree_pos_JCTree_new]

> 返回类型restype填写null或者`treeMaker.TypeIdent(TypeTag.VOID)`都代表返回void类型。另外，Java 系列面试题和答案全部整理好了，微信搜索Java技术栈，在后台发送：面试，可以在线阅读。

### 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。分享：[Spring Boot 学习笔记，这个太全了][Spring Boot]

### 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`用法非常类似。

**点击关注公众号，Java干货****及时送达**![dfc5b548fb41da64093de9385854a77e.png][]

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接下来我们就学习一些比较特殊的语法。][JCTree_pos_JCTree_new]

#### [new一个对象][JCTree_pos_JCTree_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_pos_JCTree_new] ####

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()
            )
    );

#### [方法调用（有参）][JCTree_pos_JCTree_new] ####

// 创建一个方法调用 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语句][JCTree_pos_JCTree_new] ####

/*
        创建一个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][JCTree_pos_JCTree_new]

## 总结 ##

纸上得来终觉浅，绝知此事要躬行。

希望大家看完此篇文章能够自己在本机上自己试验一下。

自己设置几个参数，自己学的Lombok学着生成一下get、set方法，虽然本篇知识在日常开发中基本上不会用到，但是万一用到了这些知识那么别人不会而你会，差距其实就慢慢的给拉开了。

本篇涉及到的所有代码都在github上面有，拉下来以后全局搜`CombatJCTreeProcessor`类就可以看到了。另外，关注公众号Java技术栈，在后台回复：面试，可以获取我整理的 Java 系列面试题和答案，非常齐全。

![1dd97f5c8dc8a6e3a94f73b2a356f5f1.gif][]

![473ff13763c2fb0cabbd00e0abc258d2.png][]

[![2f30d63c5bb81ab5cc4eb01c849d12bc.png][]][2f30d63c5bb81ab5cc4eb01c849d12bc.png 1]

[![7fd6582c8b456028a13cb52e1e7a4bac.png][]][7fd6582c8b456028a13cb52e1e7a4bac.png 1]

[![6929e20749405399d8e353626e7e28bb.png][]][6929e20749405399d8e353626e7e28bb.png 1]

[![b45a7484ed0f36ce1c0ba85751f7dc05.png][]][b45a7484ed0f36ce1c0ba85751f7dc05.png 1]

[![e42b0eb7c423a5db9207bb1aac6fca4d.png][]][e42b0eb7c423a5db9207bb1aac6fca4d.png 1]

**关注Java技术栈看更多干货**

![93cde4c03972713bce3c55383dee4f70.png][]

![71eb205413f26176f1ae36e3bec7385c.gif][]

获取 Spring Boot 实战笔记！

[2876d0ab658c265911c3eea3b2a7d930.png]: /images/20220828/896eb2d430944488a2fb36456e902d3f.png
[JCTree_pos_JCTree_new]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247540947&idx=2&sn=7faf14de2e31d03167128d6d3cc8c795&chksm=eb50a5e5dc272cf320c15c50f14bc97d3b98aa1e60fec5460824be0f057cb15ed82ba5ed2787&scene=21#wechat_redirect
[Spring Boot]: https://blog.csdn.net/superbeyone/article/details/82356271
[dfc5b548fb41da64093de9385854a77e.png]: /images/20220828/554a0dd2504747658faf8fb4591445cb.png
[1dd97f5c8dc8a6e3a94f73b2a356f5f1.gif]: /images/20220828/b59fd46e80684ceb8a3280b9b978f28c.png
[473ff13763c2fb0cabbd00e0abc258d2.png]: /images/20220828/bf87da9a2b994120ad83fda33beda9bc.png
[2f30d63c5bb81ab5cc4eb01c849d12bc.png]: /images/20220828/23595d3cc2db4edf9e6b5e9cf9dba5e8.png
[2f30d63c5bb81ab5cc4eb01c849d12bc.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247539795&idx=1&sn=1efca511169265e8146e90db220159d5&scene=21#wechat_redirect
[7fd6582c8b456028a13cb52e1e7a4bac.png]: /images/20220828/9ff90c187d3a4eb3a14782ad51e1321c.png
[7fd6582c8b456028a13cb52e1e7a4bac.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247542231&idx=1&sn=75ab147414255cc18c26b03746833be8&scene=21#wechat_redirect
[6929e20749405399d8e353626e7e28bb.png]: /images/20220828/61296fbda52a4891994fe8a2004e0ce7.png
[6929e20749405399d8e353626e7e28bb.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247540613&idx=2&sn=acbe3189c3e5d11419b8f383f36b145f&scene=21#wechat_redirect
[b45a7484ed0f36ce1c0ba85751f7dc05.png]: /images/20220828/f4ea08e4bfc64998b3d878ffca6057f4.png
[b45a7484ed0f36ce1c0ba85751f7dc05.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247537730&idx=1&sn=3869e164e482b838671fa8896cb33cdb&scene=21#wechat_redirect
[e42b0eb7c423a5db9207bb1aac6fca4d.png]: /images/20220828/847ad0f0b137468d858acb1eac01e246.png
[e42b0eb7c423a5db9207bb1aac6fca4d.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247540947&idx=1&sn=a4941f93acb4ee551534a4a1f57d9376&scene=21#wechat_redirect
[93cde4c03972713bce3c55383dee4f70.png]: /images/20220828/3cf74a0a021a421aa600085eec21b453.png
[71eb205413f26176f1ae36e3bec7385c.gif]: /images/20220828/3d668b1b91cb4551b4bf205e9a38d27d.png