精盡MyBatis原始碼分析 - MyBatis初始化（三）之 SQL 初始化（上）

該系列文件是本人在學習 Mybatis 的原始碼過程中總結下來的，可能對讀者不太友好，請結合我的原始碼註釋（Mybatis原始碼分析 GitHub 地址、Mybatis-Spring 原始碼分析 GitHub 地址、Spring-Boot-Starter 原始碼分析 GitHub 地址）進行閱讀

MyBatis 版本：3.5.2

MyBatis-Spring 版本：2.0.3

MyBatis-Spring-Boot-Starter 版本：2.1.4

MyBatis的初始化

在MyBatis初始化過程中，大致會有以下幾個步驟：

1. 建立Configuration全域性配置物件，會往TypeAliasRegistry別名註冊中心新增Mybatis需要用到的相關類，並設定預設的語言驅動類為XMLLanguageDriver

2. 載入mybatis-config.xml配置檔案、Mapper介面中的註解資訊和XML對映檔案，解析後的配置資訊會形成相應的物件並儲存到Configuration全域性配置物件中

3. 構建DefaultSqlSessionFactory物件，通過它可以建立DefaultSqlSession物件，MyBatis中SqlSession的預設實現類

因為整個初始化過程涉及到的程式碼比較多，所以拆分成了四個模組依次對MyBatis的初始化進行分析：

• 《MyBatis初始化（一）之載入mybatis-config.xml》
• 《MyBatis初始化（二）之載入Mapper介面與XML對映檔案》
• 《MyBatis初始化（三）之SQL初始化（上）》
• 《MyBatis初始化（四）之SQL初始化（下）》

由於在MyBatis的初始化過程中去解析Mapper介面與XML對映檔案涉及到的篇幅比較多，XML對映檔案的解析過程也比較複雜，所以才分成了後面三個模組，逐步分析，這樣便於理解

初始化（三）之SQL初始化（上）

在前面的MyBatis初始化相關文件中已經大致講完了MyBatis初始化的整個流程，其中遺漏了一部分，就是在解析<select /> <insert /> <update /> <delete />節點的過程中，是如何解析SQL語句，如何實現動態SQL語句，最終會生成一個org.apache.ibatis.mapping.SqlSource物件的，對於這煩瑣且易出錯的過程，我們來看看MyBatis如何實現的？

我們回顧org.apache.ibatis.builder.xml.XMLStatementBuilder的parseStatementNode()解析 Statement 節點時，通過下面的方法建立對應的SqlSource物件

// 建立對應的 SqlSource 物件，儲存了該節點下 SQL 相關資訊
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

langDriver是從Configuration全域性配置物件中獲取的預設實現類，對應的也就是XMLLanguageDriver，在Configuration初始化的時候設定的

public Configuration() {
    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
	languageRegistry.register(RawLanguageDriver.class);
}

主要包路徑：org.apache.ibatis.scripting、org.apache.ibatis.builder、org.apache.ibatis.mapping

主要涉及到的類：

• org.apache.ibatis.scripting.xmltags.XMLLanguageDriver：語言驅動介面的預設實現，建立ParameterHandler引數處理器物件和SqlSource資源物件

• org.apache.ibatis.scripting.xmltags.XMLScriptBuilder：繼承 BaseBuilder 抽象類，負責將SQL指令碼（XML或者註解中定義的SQL語句）解析成SqlSource（DynamicSqlSource或者RawSqlSource）資源物件

• org.apache.ibatis.scripting.xmltags.XMLScriptBuilder.NodeHandler：定義在XMLScriptBuilder內部的一個介面，用於處理MyBatis自定義標籤（<if /> <foreach />等），生成對應的SqlNode物件，不同的實現類處理不同的標籤

• org.apache.ibatis.scripting.xmltags.DynamicContext：解析動態SQL語句時的上下文，用於解析SQL時，記錄動態SQL處理後的SQL語句，內部提供ContextMap物件儲存上下文的引數

• org.apache.ibatis.scripting.xmltags.SqlNode：SQL Node介面，每個XML Node會解析成對應的SQL Node物件，通過上下文可以對動態SQL進行邏輯處理，生成需要的結果

• org.apache.ibatis.scripting.xmltags.OgnlCache：用於處理Ognl表示式

語言驅動介面的實現類如下圖所示：

LanguageDriver

org.apache.ibatis.scripting.LanguageDriver：語言驅動介面，程式碼如下：

public interface LanguageDriver {

	/**
	 * Creates a {@link ParameterHandler} that passes the actual parameters to the the JDBC statement.
	 * 建立 ParameterHandler 物件
	 *
	 * @param mappedStatement The mapped statement that is being executed
	 * @param parameterObject The input parameter object (can be null)
	 * @param boundSql        The resulting SQL once the dynamic language has been executed.
	 * @return 引數處理器
	 * @author Frank D. Martinez [mnesarco]
	 * @see DefaultParameterHandler
	 */
	ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql);

	/**
	 * Creates an {@link SqlSource} that will hold the statement read from a mapper xml file. 
	 * It is called during startup, when the mapped statement is read from a class or an xml file.
	 * 建立 SqlSource 物件，從 Mapper XML 配置的 Statement 標籤中，即 <select /> 等。
	 *
	 * @param configuration The MyBatis configuration
	 * @param script        XNode parsed from a XML file
	 * @param parameterType input parameter type got from a mapper method or specified in the parameterType xml attribute. Can be null.
	 * @return SQL 資源
	 */
	SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType);

	/**
	 * Creates an {@link SqlSource} that will hold the statement read from an annotation. 
	 * It is called during startup, when the mapped statement is read from a class or an xml file.
	 * 建立 SqlSource 物件，從方法註解配置，即 @Select 等。
	 *
	 * @param configuration The MyBatis configuration
	 * @param script        The content of the annotation
	 * @param parameterType input parameter type got from a mapper method or specified in the parameterType xml attribute. Can be null.
	 * @return SQL 資源
	 */
	SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType);
}

定義了三個方法：

1. createParameterHandler：獲取 ParameterHandler 引數處理器物件

2. createSqlSource：建立 SqlSource 物件，解析 Mapper XML 配置的 Statement 標籤中，即 <select /> <update /> <delete /> <insert />

3. createSqlSource：建立 SqlSource 物件，從方法註解配置，即 @Select 等

XMLLanguageDriver

org.apache.ibatis.scripting.xmltags.XMLLanguageDriver：語言驅動介面的預設實現，程式碼如下：

public class XMLLanguageDriver implements LanguageDriver {

  @Override
  public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    // 建立 DefaultParameterHandler 物件
    return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
  }

  /**
   * 用於解析 XML 對映檔案中的 SQL
   *
   * @param configuration The MyBatis configuration
   * @param script        XNode parsed from a XML file
   * @param parameterType input parameter type got from a mapper method or
   *                      specified in the parameterType xml attribute. Can be
   *                      null.
   * @return SQL 資源
   */
  @Override
  public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    // 建立 XMLScriptBuilder 物件，執行解析
    XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
    return builder.parseScriptNode();
  }

  /**
   * 用於解析註解中的 SQL
   *
   * @param configuration The MyBatis configuration
   * @param script        The content of the annotation
   * @param parameterType input parameter type got from a mapper method or
   *                      specified in the parameterType xml attribute. Can be
   *                      null.
   * @return SQL 資源
   */
  @Override
  public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
    // issue #3
    // <1> 如果是 <script> 開頭，表示是在註解中使用的動態 SQL
    if (script.startsWith("<script>")) {
      // <1.1> 建立 XPathParser 物件，解析出 <script /> 節點
      XPathParser parser = new XPathParser(script, false, configuration.getVariables(), new XMLMapperEntityResolver());
      return createSqlSource(configuration, parser.evalNode("/script"), parameterType);
    } else {
      // issue #127
      // <2.1> 變數替換
      script = PropertyParser.parse(script, configuration.getVariables());
      // <2.2> 建立 TextSqlNode 物件
      TextSqlNode textSqlNode = new TextSqlNode(script);
      if (textSqlNode.isDynamic()) { // <2.3.1> 如果是動態 SQL ，則建立 DynamicSqlSource 物件
        return new DynamicSqlSource(configuration, textSqlNode);
      } else { // <2.3.2> 如果非動態 SQL ，則建立 RawSqlSource 物件
        return new RawSqlSource(configuration, script, parameterType);
      }
    }
  }
}

實現了LanguageDriver介面：

1. 建立 DefaultParameterHandler 預設引數處理器並返回

2. 解析 XML 對映檔案中的 SQL，通過建立 XMLScriptBuilder 物件，呼叫其 parseScriptNode() 方法解析

3. 解析註解定義的 SQL

   1. 如果是 <script> 開頭，表示是在註解中使用的動態 SQL，將其轉換成 XNode 然後呼叫上述方法，不瞭解的可以看看MyBatis三種動態SQL配置方式
   2. 先將註解中定義的 SQL 中包含的變數進行轉換，然後建立對應的 SqlSource 物件

RawLanguageDriver

org.apache.ibatis.scripting.defaults.RawLanguageDriver：繼承了XMLLanguageDriver，在的基礎上增加了是否為靜態SQL語句的校驗，也就是判斷建立的 SqlSource 是否為 RawSqlSource 靜態 SQL 資源

XMLScriptBuilder

org.apache.ibatis.scripting.xmltags.XMLScriptBuilder：繼承 BaseBuilder 抽象類，負責將 SQL 指令碼（XML或者註解中定義的 SQL ）解析成 SqlSource 物件

構造方法

public class XMLScriptBuilder extends BaseBuilder {
    /**
	 * 當前 SQL 的 XNode 物件
	 */
	private final XNode context;
	/**
	 * 是否為動態 SQL
	 */
	private boolean isDynamic;
	/**
	 * SQL 的 Java 入參型別
	 */
	private final Class<?> parameterType;
	/**
	 * NodeNodeHandler 的對映
	 */
	private final Map<String, NodeHandler> nodeHandlerMap = new HashMap<>();

	public XMLScriptBuilder(Configuration configuration, XNode context) {
		this(configuration, context, null);
	}

	public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
		super(configuration);
		this.context = context;
		this.parameterType = parameterType;
		initNodeHandlerMap();
	}

	private void initNodeHandlerMap() {
		nodeHandlerMap.put("trim", new TrimHandler());
		nodeHandlerMap.put("where", new WhereHandler());
		nodeHandlerMap.put("set", new SetHandler());
		nodeHandlerMap.put("foreach", new ForEachHandler());
		nodeHandlerMap.put("if", new IfHandler());
		nodeHandlerMap.put("choose", new ChooseHandler());
		nodeHandlerMap.put("when", new IfHandler());
		nodeHandlerMap.put("otherwise", new OtherwiseHandler());
		nodeHandlerMap.put("bind", new BindHandler());
	}
}

在建構函式中會初始化 NodeHandler 處理器，分別用於處理不同的MyBatis自定義的XML標籤，例如<if /> <where /> <foreach />等標籤

parseScriptNode方法

parseScriptNode()方法將 SQL 指令碼（XML或者註解中定義的 SQL ）解析成 SqlSource 物件，程式碼如下：

public SqlSource parseScriptNode() {
    // 解析 XML 或者註解中定義的 SQL
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) {
        // 動態語句，使用了 ${} 也算
        sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
        sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
}

1. 通過呼叫parseDynamicTags(XNode node)方法，將解析 SQL 成 MixedSqlNode 物件，主要是將一整個 SQL 解析成一系列的 SqlNode 物件
2. 如果是動態SQL語句，使用了MyBatis自定義的XML標籤（<if />等）或者使用了${}，則封裝成DynamicSqlSource物件
3. 否則就是靜態SQL語句，封裝成RawSqlSource物件

parseDynamicTags方法

parseDynamicTags()將 SQL 指令碼（XML或者註解中定義的 SQL ）解析成MixedSqlNode物件，程式碼如下：

protected MixedSqlNode parseDynamicTags(XNode node) {
    // <1> 建立 SqlNode 陣列
    List<SqlNode> contents = new ArrayList<>();
    /*
     * <2> 遍歷 SQL 節點中所有子節點
     * 這裡會對該節點內的所有內容進行處理然後返回 NodeList 物件
     * 1. 文字內容會被解析成 '<#text></#text>' 節點，就算一個換行符也會解析成這個
     * 2. <![CDATA[ content ]]> 會被解析成 '<#cdata-section>content</#cdata-section>' 節點
     * 3. 其他動態<if /> <where />
     */
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        // 當前子節點
        XNode child = node.newXNode(children.item(i));
        // <2.1> 如果型別是 Node.CDATA_SECTION_NODE 或者 Node.TEXT_NODE 時
        if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE // <![CDATA[ ]]>節點
                || child.getNode().getNodeType() == Node.TEXT_NODE) { // 純文字
            // <2.1.1> 獲得內容
            String data = child.getStringBody("");
            // <2.1.2> 建立 TextSqlNode 物件
            TextSqlNode textSqlNode = new TextSqlNode(data);
            if (textSqlNode.isDynamic()) { // <2.1.2.1> 如果是動態的 TextSqlNode 物件，也就是使用了 '${}'
                // 新增到 contents 中
                contents.add(textSqlNode);
                // 標記為動態 SQL
                isDynamic = true;
            } else { // <2.1.2.2> 如果是非動態的 TextSqlNode 物件，沒有使用 '${}'
                // <2.1.2> 建立 StaticTextSqlNode 新增到 contents 中
                contents.add(new StaticTextSqlNode(data));
            }
        } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628 <2.2> 如果型別是 Node.ELEMENT_NODE
            // <2.2.1> 根據子節點的標籤，獲得對應的 NodeHandler 物件
            String nodeName = child.getNode().getNodeName();
            NodeHandler handler = nodeHandlerMap.get(nodeName);
            if (handler == null) { // 獲得不到，說明是未知的標籤，丟擲 BuilderException 異常
                throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
            }
            // <2.2.2> 執行 NodeHandler 處理
            handler.handleNode(child, contents);
            // <2.2.3> 標記為動態 SQL
            isDynamic = true;
        }
    }
    // <3> 建立 MixedSqlNode 物件
    return new MixedSqlNode(contents);
}

<1> 建立 SqlNode 陣列 contents，用於儲存解析 SQL 後的一些列 SqlNode 物件

<2> 獲取定義的 SQL 節點中所有子節點，返回一個 NodeList 物件，這個物件中包含了該 SQL 節點內的所有資訊，然後逐個遍歷子節點

1. 其中文字內容會被解析成`<#text></#text>`節點，就算一個換行符也會解析成這個
   	2. `<![CDATA[ ]]>` 會被解析成 `<#cdata-section></#cdata-section>` 節點
         	3. 還有其他MyBatis自定義的標籤`<if /> <where />`等等

<2.1> 如果子節點是<#text />或者<#cdata-section />型別

​ <2.1.1> 獲取子節點的文字內容

​ <2.1.2> 建立 TextSqlNode 物件

​ <2.1.2.1> 呼叫 TextSqlNode 的 isDynamic() 方法，點選去該進去看看就知道了，如果文字中使用了${}，則標記為動態 SQL 語句，將其新增至 contents 陣列中

​ <2.1.2.2> 否則就是靜態文字內容，建立對應的 StaticTextSqlNode 物件，將其新增至 contents 陣列中

<2.2> 如果型別是 Node.ELEMENT_NODE 時，也就是 MyBatis 的自定義標籤

​ <2.2.1> 根據子節點的標籤名稱，獲得對應的 NodeHandler 物件

​ <2.2.2> 執行NodeHandler的handleNode方法處理該節點，建立不通型別的 SqlNode 並新增到 contents 陣列中，如何處理的在下面講述

​ <2.2.3> 標記為動態 SQL 語句

<3> 最後將建立 contents 封裝成 MixedSqlNode 物件

NodeHandler

XMLScriptBuilder的內部介面，用於處理MyBatis自定義標籤，介面實現類如下圖所示：

程式碼如下：

private interface NodeHandler {
    /**
     * 處理 Node
     *
     * @param nodeToHandle   要處理的 XNode 節點
     * @param targetContents 目標的 SqlNode 陣列。實際上，被處理的 XNode 節點會建立成對應的 SqlNode 物件，新增到 targetContents 中
     */
    void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
}

這些 NodeHandler 實現類都定義在 XMLScriptBuilder 內部，用於處理不同標籤，我們逐個來看

BindHandler

實現了NodeHandler介面，<bind />標籤的處理器，程式碼如下：

/**
 * <bind />元素允許你在 OGNL 表示式(SQL語句)以外建立一個變數，並將其繫結到當前的上下文
 */
private class BindHandler implements NodeHandler {
    public BindHandler() {
        // Prevent Synthetic Access
    }
    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析 name、value 屬性
        final String name = nodeToHandle.getStringAttribute("name");
        final String expression = nodeToHandle.getStringAttribute("value");
        // 建立 VarDeclSqlNode 物件
        final VarDeclSqlNode node = new VarDeclSqlNode(name, expression);
        targetContents.add(node);
    }
}

1. 獲取<bind />標籤的name和value屬性

2. 根據這些屬性建立一個 VarDeclSqlNode 物件

3. 新增到targetContents集合中

例如這樣配置：

<select id="selectBlogsLike" resultType="Blog">
  <bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />
  SELECT * FROM BLOG
  WHERE title LIKE #{pattern}
</select>

TrimHandler

實現了NodeHandler介面，<trim />標籤的處理器，程式碼如下：

private class TrimHandler implements NodeHandler {
    public TrimHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // <1> 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // <2> 獲得 prefix、prefixOverrides、"suffix"、suffixOverrides 屬性
        String prefix = nodeToHandle.getStringAttribute("prefix");
        String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
        String suffix = nodeToHandle.getStringAttribute("suffix");
        String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
        // <3> 建立 TrimSqlNode 物件
        TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
        targetContents.add(trim);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<if />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件

2. 獲得 prefix、prefixOverrides、suffix、suffixOverrides 屬性

3. 根據上面獲取到的屬性建立TrimSqlNode物件

4. 新增到targetContents集合中

WhereHandler

實現了NodeHandler介面，<where />標籤的處理器，程式碼如下：

private class WhereHandler implements NodeHandler {
    public WhereHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // 建立 WhereSqlNode 物件
        WhereSqlNode where = new WhereSqlNode(configuration, mixedSqlNode);
        targetContents.add(where);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<where />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
2. 建立WhereSqlNode物件，該物件繼承了TrimSqlNode，自定義字首（WHERE）和需要刪除的字首（AND、OR等）
3. 新增到targetContents集合中

SetHandler

實現了NodeHandler介面，<set />標籤的處理器，程式碼如下：

private class SetHandler implements NodeHandler {
    public SetHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        SetSqlNode set = new SetSqlNode(configuration, mixedSqlNode);
        targetContents.add(set);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<set />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
2. 建立SetSqlNode物件，該物件繼承了TrimSqlNode，自定義字首（SET）和需要刪除的字首和字尾（,）
3. 新增到targetContents集合中

ForEachHandler

實現了NodeHandler介面，<foreach />標籤的處理器，程式碼如下：

private class ForEachHandler implements NodeHandler {
    public ForEachHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // 獲得 collection、item、index、open、close、separator 屬性
        String collection = nodeToHandle.getStringAttribute("collection");
        String item = nodeToHandle.getStringAttribute("item");
        String index = nodeToHandle.getStringAttribute("index");
        String open = nodeToHandle.getStringAttribute("open");
        String close = nodeToHandle.getStringAttribute("close");
        String separator = nodeToHandle.getStringAttribute("separator");
        // 建立 ForEachSqlNode 物件
        ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, index, item, open, close, separator);
        targetContents.add(forEachSqlNode);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<foreach />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
2. 獲得 collection、item、index、open、close、separator 屬性
3. 根據這些屬性建立ForEachSqlNode物件
4. 新增到targetContents集合中

IfHandler

實現了NodeHandler介面，<if />標籤的處理器，程式碼如下：

private class IfHandler implements NodeHandler {
    public IfHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // 獲得 test 屬性
        String test = nodeToHandle.getStringAttribute("test");
        // 建立 IfSqlNode 物件
        IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
        targetContents.add(ifSqlNode);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<if />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
2. 獲得 test 屬性
3. 根據這個屬性建立IfSqlNode物件
4. 新增到targetContents集合中

OtherwiseHandler

實現了NodeHandler介面，<otherwise />標籤的處理器，程式碼如下：

private class OtherwiseHandler implements NodeHandler {
    public OtherwiseHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 解析內部的 SQL 節點，成 MixedSqlNode 物件
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        targetContents.add(mixedSqlNode);
    }
}

1. 繼續呼叫parseDynamicTags方法解析<otherwise />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
2. 新增到targetContents集合中，需要結合ChooseHandler使用

ChooseHandler

實現了NodeHandler介面，<choose />標籤的處理器，程式碼如下：

private class ChooseHandler implements NodeHandler {
    public ChooseHandler() {
        // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        List<SqlNode> whenSqlNodes = new ArrayList<>();
        List<SqlNode> otherwiseSqlNodes = new ArrayList<>();
        // 解析 `<when />` 和 `<otherwise />` 的節點們
        handleWhenOtherwiseNodes(nodeToHandle, whenSqlNodes, otherwiseSqlNodes);
        // 獲得 `<otherwise />` 的節點，存在多個會丟擲異常
        SqlNode defaultSqlNode = getDefaultSqlNode(otherwiseSqlNodes);
        // 建立 ChooseSqlNode 物件
        ChooseSqlNode chooseSqlNode = new ChooseSqlNode(whenSqlNodes, defaultSqlNode);
        targetContents.add(chooseSqlNode);
    }

    private void handleWhenOtherwiseNodes(XNode chooseSqlNode, List<SqlNode> ifSqlNodes,
            List<SqlNode> defaultSqlNodes) {
        List<XNode> children = chooseSqlNode.getChildren();
        for (XNode child : children) {
            String nodeName = child.getNode().getNodeName();
            NodeHandler handler = nodeHandlerMap.get(nodeName);
            if (handler instanceof IfHandler) { // 處理 `<when />` 標籤的情況
                handler.handleNode(child, ifSqlNodes);
            } else if (handler instanceof OtherwiseHandler) { // 處理 `<otherwise />` 標籤的情況
                handler.handleNode(child, defaultSqlNodes);
            }
        }
    }

    private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) {
        SqlNode defaultSqlNode = null;
        if (defaultSqlNodes.size() == 1) {
            defaultSqlNode = defaultSqlNodes.get(0);
        } else if (defaultSqlNodes.size() > 1) {
            throw new BuilderException("Too many default (otherwise) elements in choose statement.");
        }
        return defaultSqlNode;
    }
}

1. 先逐步處理<choose />標籤的<when /> 和 <otherwise />子標籤們，通過組合 IfHandler 和 OtherwiseHandler 兩個處理器，實現對子節點們的解析

2. 如果存在<otherwise />子標籤，則丟擲異常

3. 根據這些屬性建立ChooseSqlNode物件

4. 新增到targetContents集合中

DynamicContext

org.apache.ibatis.scripting.xmltags.DynamicContext：解析動態SQL語句時的上下文，用於解析SQL時，記錄動態SQL處理後的SQL語句，內部提供ContextMap物件儲存上下文的引數

構造方法

public class DynamicContext {

  /**
   * 入參儲存在 ContextMap 中的 Key
   *
   * {@link #bindings}
   */
  public static final String PARAMETER_OBJECT_KEY = "_parameter";
  /**
   * 資料庫編號儲存在 ContextMap 中的 Key
   *
   * {@link #bindings}
   */
  public static final String DATABASE_ID_KEY = "_databaseId";

  static {
    // <1.2> 設定 OGNL 的屬性訪問器
    OgnlRuntime.setPropertyAccessor(ContextMap.class, new ContextAccessor());
  }

  /**
   * 上下文的引數集合，包含附加引數（通過`<bind />`標籤生成的，或者`<foreach />`標籤中的集合的元素等等）
   */
  private final ContextMap bindings;
  /**
   * 生成後的 SQL
   */
  private final StringJoiner sqlBuilder = new StringJoiner(" ");
  /**
   * 唯一編號。在 {@link org.apache.ibatis.scripting.xmltags.XMLScriptBuilder.ForEachHandler} 使用
   */
  private int uniqueNumber = 0;

  public DynamicContext(Configuration configuration, Object parameterObject) {
    // <1> 初始化 bindings 引數
    if (parameterObject != null && !(parameterObject instanceof Map)) {
      // 構建入參的 MetaObject 物件
      MetaObject metaObject = configuration.newMetaObject(parameterObject);
      // 入參型別是否有對應的型別處理器
      boolean existsTypeHandler = configuration.getTypeHandlerRegistry().hasTypeHandler(parameterObject.getClass());
      bindings = new ContextMap(metaObject, existsTypeHandler);
    } else {
      bindings = new ContextMap(null, false);
    }
    // <2> 新增 bindings 的預設值
    bindings.put(PARAMETER_OBJECT_KEY, parameterObject);
    bindings.put(DATABASE_ID_KEY, configuration.getDatabaseId());
  }
}

型別	屬性	說明
ContextMap	bindings	上下文的引數集合，包含附加引數（通過<bind />標籤生成的，或者<foreach />標籤解析引數儲存的），以及幾個預設值
StringJoiner	sqlBuilder	儲存本次解析後的SQL，每次新增字串以空格作為分隔符
int	uniqueNumber	唯一編號，在ForEachHandler處理節點時需要用到，生成唯一陣列作為集合中每個元素的索引（作為字尾）

1. 初始化bindings引數，建立 ContextMap 物件
   1. 根據入參轉換成MetaObject物件
   2. 在靜態程式碼塊中，設定OGNL的屬性訪問器，OgnlRuntime 是 OGNL 庫中的類，設定ContextMap對應的訪問器是ContextAccessor類
2. 往bindings中新增幾個預設值：_parameter > 入參物件，_databaseId -> 資料庫識別符號

ContextMap

DynamicContext的內部靜態類，繼承HashMap，用於儲存解析動態SQL語句時的上下文的引數集合，程式碼如下：

static class ContextMap extends HashMap<String, Object> {
    private static final long serialVersionUID = 2977601501966151582L;
    /**
     * parameter 對應的 MetaObject 物件
     */
    private final MetaObject parameterMetaObject;
    /**
     * 是否有對應的型別處理器
     */
    private final boolean fallbackParameterObject;

    public ContextMap(MetaObject parameterMetaObject, boolean fallbackParameterObject) {
      this.parameterMetaObject = parameterMetaObject;
      this.fallbackParameterObject = fallbackParameterObject;
    }

    @Override
    public Object get(Object key) {
      String strKey = (String) key;
      if (super.containsKey(strKey)) {
        return super.get(strKey);
      }

      if (parameterMetaObject == null) {
        return null;
      }

      if (fallbackParameterObject && !parameterMetaObject.hasGetter(strKey)) {
        return parameterMetaObject.getOriginalObject();
      } else {
        // issue #61 do not modify the context when reading
        return parameterMetaObject.getValue(strKey);
      }
    }
}

重寫了 HashMap 的 get(Object key) 方法，增加支援對 parameterMetaObject 屬性的訪問

ContextAccessor

DynamicContext的內部靜態類，實現 ognl.PropertyAccessor 介面，上下文訪問器，程式碼如下：

static class ContextAccessor implements PropertyAccessor {
    @Override
    public Object getProperty(Map context, Object target, Object name) {
      Map map = (Map) target;

      // 優先從 ContextMap 中，獲得屬性
      Object result = map.get(name);
      if (map.containsKey(name) || result != null) {
        return result;
      }

      // <x> 如果沒有，則從 PARAMETER_OBJECT_KEY 對應的 Map 中，獲得屬性
      Object parameterObject = map.get(PARAMETER_OBJECT_KEY);
      if (parameterObject instanceof Map) {
        return ((Map) parameterObject).get(name);
      }

      return null;
    }

    @Override
    public void setProperty(Map context, Object target, Object name, Object value) {
      Map<Object, Object> map = (Map<Object, Object>) target;
      map.put(name, value);
    }

    @Override
    public String getSourceAccessor(OgnlContext arg0, Object arg1, Object arg2) {
      return null;
    }

    @Override
    public String getSourceSetter(OgnlContext arg0, Object arg1, Object arg2) {
      return null;
    }
}

在DynamicContext的靜態程式碼塊中，設定OGNL的屬性訪問器，設定了ContextMap.class的屬性訪問器為ContextAccessor

這裡方法的入參中的target，就是 ContextMap 物件

1. 在重寫的getProperty方法中，先從 ContextMap 裡面獲取屬性值（可以回過去看下ContextMap的get方法）

2. 沒有獲取到則獲取 PARAMETER_OBJECT_KEY 屬性的值，如果是 Map 型別，則從這裡面獲取屬性值

回看 DynamicContext 的構造方法，細品一下???，先從Map中獲取屬性值，沒有獲取到則從parameterObject入參物件中獲取屬性值

SqlNode

org.apache.ibatis.scripting.xmltags.SqlNode：SQL Node介面，每個XML Node會解析成對應的SQL Node物件，通過上下文可以對動態SQL進行邏輯處理，生成需要的結果

實現類如下圖所示：

程式碼如下：

public interface SqlNode {
	/**
	 * 應用當前 SQLNode 節點
	 *
	 * @param context 正在解析 SQL 語句的上下文
	 * @return 是否應用成功
	 */
	boolean apply(DynamicContext context);
}

因為在解析SQL語句的時候我們需要根據入參來處理不同的SqlNode，通過其apply(DynamicContext context)方法應用SqlNode節點，將節點轉換成相應的SQL

我們來看看它的實現類是如何處理相應的SQL Node的

VarDeclSqlNode

org.apache.ibatis.scripting.xmltags.VarDeclSqlNode：實現 SqlNode 介面，<bind /> 標籤對應的 SqlNode 實現類，程式碼如下：

public class VarDeclSqlNode implements SqlNode {
    /**
     * 變數名稱
     */
	private final String name;
    /**
     * 表示式
     */
	private final String expression;

	public VarDeclSqlNode(String var, String exp) {
		name = var;
		expression = exp;
	}

	@Override
	public boolean apply(DynamicContext context) {
	    // 獲取該表示式轉換後結果
		final Object value = OgnlCache.getValue(expression, context.getBindings());
		// 將該結果與變數名稱設定到解析 SQL 語句的上下文中，這樣接下來的解析過程中可以獲取到 name 的值
		context.bind(name, value);
		return true;
	}
}

1. 通過OGNL表示式expression從DynamicContext上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面講到

2. 將name與轉換後的結果繫結到DynamicContext上下文中，後續處理其他節點可以獲取到

TrimSqlNode

org.apache.ibatis.scripting.xmltags.TrimSqlNode：實現 SqlNode 介面，<trim/> 標籤對應的 SqlNode 實現類

構造方法

public class TrimSqlNode implements SqlNode {
	/**
	 * MixedSqlNode，包含該<if />節點內所有資訊
	 */
	private final SqlNode contents;
	/**
	 * 字首，行首新增
	 */
	private final String prefix;
	/**
	 * 字尾，行尾新增
	 */
	private final String suffix;
	/**
	 * 需要刪除的字首，例如這樣定義：'AND|OR'
	 * 注意空格，這裡是不會去除的
	 */
	private final List<String> prefixesToOverride;
	/**
	 * 需要刪除的字尾，例如我們這樣定義：',|AND'
	 * 注意空格，這裡是不會去除的
	 */
	private final List<String> suffixesToOverride;
	private final Configuration configuration;

	public TrimSqlNode(Configuration configuration, SqlNode contents, String prefix, String prefixesToOverride,
			String suffix, String suffixesToOverride) {
		this(configuration, contents, prefix, parseOverrides(prefixesToOverride), suffix, parseOverrides(suffixesToOverride));
	}

	protected TrimSqlNode(Configuration configuration, SqlNode contents, String prefix, List<String> prefixesToOverride,
			String suffix, List<String> suffixesToOverride) {
		this.contents = contents;
		this.prefix = prefix;
		this.prefixesToOverride = prefixesToOverride;
		this.suffix = suffix;
		this.suffixesToOverride = suffixesToOverride;
		this.configuration = configuration;
	}
}

在構造方法中解析<trim />標籤的屬性，其中呼叫了parseOverrides方法將|作為分隔符分隔該字串並全部大寫，生成一個陣列，相關屬性可檢視上面的註釋

apply方法

@Override
public boolean apply(DynamicContext context) {
    // <1> 建立 FilteredDynamicContext 物件
    FilteredDynamicContext filteredDynamicContext = new FilteredDynamicContext(context);
    // <2> 先解析 <trim /> 節點中的內容，將生成的 SQL 先存放在 FilteredDynamicContext 中
    boolean result = contents.apply(filteredDynamicContext);
    /*
     * <3> 執行 FilteredDynamicContext 的應用
     * 對上一步解析到的內容進行處理
     * 處理完成後再將處理後的 SQL 拼接到 DynamicContext 中
     */
    filteredDynamicContext.applyAll();
    return result;
}

1. 通過裝飾器模式將context裝飾成FilteredDynamicContext物件

2. 因為<trim />標籤中定義了內容或者其他標籤，都會解析成相應的SqlNode，儲存在contents中（MixedSqlNode）

   所以這裡需要先應用內部的SqlNode，轉換後的SQL會先儲存在FilteredDynamicContext中

3. 對FilteredDynamicContext中的SQL進行處理，也就是新增前字尾，去除前字尾的處理邏輯，然後將處理後的SQL拼接到context中

FilteredDynamicContext

TrimSqlNode的私有內部類，繼承了DynamicContext類，對<trim />標籤邏輯的實現，程式碼如下：

private class FilteredDynamicContext extends DynamicContext {
    /**
     * 裝飾的 DynamicContext 物件
     */
    private DynamicContext delegate;
    /**
     * 是否 prefix 已經被應用
     */
    private boolean prefixApplied;
    /**
     * 是否 suffix 已經被應用
     */
    private boolean suffixApplied;
    /**
     * StringBuilder 物件
     *
     * @see #appendSql(String)
     */
    private StringBuilder sqlBuffer;

    public FilteredDynamicContext(DynamicContext delegate) {
        super(configuration, null);
        this.delegate = delegate;
        this.prefixApplied = false;
        this.suffixApplied = false;
        this.sqlBuffer = new StringBuilder();
    }

    public void applyAll() {
        // <1> 去除前後多餘的空格，生成新的 sqlBuffer 物件
        sqlBuffer = new StringBuilder(sqlBuffer.toString().trim());
        // <2> 全部大寫
        String trimmedUppercaseSql = sqlBuffer.toString().toUpperCase(Locale.ENGLISH);
        // <3> 應用 TrimSqlNode 的 trim 邏輯
        if (trimmedUppercaseSql.length() > 0) {
            applyPrefix(sqlBuffer, trimmedUppercaseSql);
            applySuffix(sqlBuffer, trimmedUppercaseSql);
        }
        delegate.appendSql(sqlBuffer.toString());
    }

    @Override
    public Map<String, Object> getBindings() {
        return delegate.getBindings();
    }

    @Override
    public void bind(String name, Object value) {
        delegate.bind(name, value);
    }

    @Override
    public int getUniqueNumber() {
        return delegate.getUniqueNumber();
    }

    @Override
    public void appendSql(String sql) {
        sqlBuffer.append(sql);
    }

    @Override
    public String getSql() {
        return delegate.getSql();
    }

    private void applyPrefix(StringBuilder sql, String trimmedUppercaseSql) {
        if (!prefixApplied) {
            prefixApplied = true;
            // prefixesToOverride 非空，先刪除
            if (prefixesToOverride != null) {
                for (String toRemove : prefixesToOverride) {
                    if (trimmedUppercaseSql.startsWith(toRemove)) {
                        sql.delete(0, toRemove.trim().length());
                        break;
                    }
                }
            }
            // prefix 非空，再新增
            if (prefix != null) {
                sql.insert(0, " ");
                sql.insert(0, prefix);
            }
        }
    }

    private void applySuffix(StringBuilder sql, String trimmedUppercaseSql) {
        if (!suffixApplied) {
            suffixApplied = true;
            // suffixesToOverride 非空，先刪除
            if (suffixesToOverride != null) {
                for (String toRemove : suffixesToOverride) {
                    if (trimmedUppercaseSql.endsWith(toRemove) || trimmedUppercaseSql.endsWith(toRemove.trim())) {
                        int start = sql.length() - toRemove.trim().length();
                        int end = sql.length();
                        sql.delete(start, end);
                        break;
                    }
                }
            }
            // suffix 非空，再新增
            if (suffix != null) {
                sql.append(" ");
                sql.append(suffix);
            }
        }
    }
}

邏輯並不複雜，大家可以看下

WhereSqlNode

org.apache.ibatis.scripting.xmltags.WhereSqlNode：繼承了TrimSqlNode類，<where /> 標籤對應的 SqlNode 實現類，程式碼如下：

public class WhereSqlNode extends TrimSqlNode {

    /**
     * 也是通過 TrimSqlNode ，這裡定義需要刪除的字首
     */
	private static List<String> prefixList = Arrays.asList("AND ", "OR ", "AND\n", "OR\n", "AND\r", "OR\r", "AND\t", "OR\t");

	public WhereSqlNode(Configuration configuration, SqlNode contents) {
	  // 設定字首和需要刪除的字首
		super(configuration, contents, "WHERE", prefixList, null, null);
	}
}

基於TrimSqlNode類，定義了需要新增的字首為WHERE和需要刪除的字首AND和OR

SetSqlNode

org.apache.ibatis.scripting.xmltags.SetSqlNode：繼承了TrimSqlNode類，<set /> 標籤對應的 SqlNode 實現類，程式碼如下：

public class SetSqlNode extends TrimSqlNode {

  /**
   * 也是通過 TrimSqlNode ，這裡定義需要刪除的字首
   */
  private static final List<String> COMMA = Collections.singletonList(",");

  public SetSqlNode(Configuration configuration,SqlNode contents) {
    // 設定字首、需要刪除的字首和字尾
    super(configuration, contents, "SET", COMMA, null, COMMA);
  }

}

基於TrimSqlNode類，定義了需要新增的字首為SET、需要刪除的字首,和需要刪除的字尾,

ForeachNode

org.apache.ibatis.scripting.xmltags.ForeachNode：實現 SqlNode 介面，<foreach /> 標籤對應的 SqlNode 實現類

其中apply(DynamicContext context)方法的處理邏輯饒了我半天，大家可以仔細看一下

構造方法

public class ForEachSqlNode implements SqlNode {
    /**
     * 集合中元素繫結到上下文中 key 的字首
     */
	public static final String ITEM_PREFIX = "__frch_";
	/**
	 * 表示式計算器
	 */
	private final ExpressionEvaluator evaluator;
    /**
     * 需要遍歷的集合型別，支援：list set map array
     */
	private final String collectionExpression;
    /**
     * MixedSqlNode，包含該<where />節點內所有資訊
     */
	private final SqlNode contents;
    /**
     * 開頭
     */
	private final String open;
    /**
     * 結尾
     */
	private final String close;
    /**
     * 每個元素以什麼分隔
     */
	private final String separator;
	/**
	 * 集合中每個元素的值
	 */
	private final String item;
	/**
	 * 集合中每個元素的索引
	 */
	private final String index;
	private final Configuration configuration;

	public ForEachSqlNode(Configuration configuration, SqlNode contents, String collectionExpression, String index,
			String item, String open, String close, String separator) {
		this.evaluator = new ExpressionEvaluator();
		this.collectionExpression = collectionExpression;
		this.contents = contents;
		this.open = open;
		this.close = close;
		this.separator = separator;
		this.index = index;
		this.item = item;
		this.configuration = configuration;
	}
}

對每個屬性進行賦值，參考每個屬性上面的註釋

apply方法

@Override
public boolean apply(DynamicContext context) {
    // 獲取入參
    Map<String, Object> bindings = context.getBindings();
    /*
     * <1> 獲得遍歷的集合的 Iterable 物件，用於遍歷
     * 例如配置了 collection 為以下型別
     * list：則從入參中獲取到 List 集合型別的屬性的值
     * array：則從入參中獲取到 Array 陣列型別的屬性的值，會轉換成 ArrayList
     * map：則從入參中獲取到 Map 集合型別的屬性的值
     */
    final Iterable<?> iterable = evaluator.evaluateIterable(collectionExpression, bindings);
    if (!iterable.iterator().hasNext()) {
        // 集合中沒有元素則無需遍歷
        return true;
    }
    boolean first = true;
    // <2> 新增 open 到 SQL 中
    applyOpen(context);
    int i = 0;
    for (Object o : iterable) {
        // <3> 記錄原始的 context 物件，下面通過兩個裝飾器對他進行操作
        DynamicContext oldContext = context;
        // <4> 生成一個 context 裝飾器
        if (first || separator == null) {
            context = new PrefixedContext(context, "");
        } else {
            // 設定其需要新增的字首為分隔符
            context = new PrefixedContext(context, separator);
        }
        // <5> 生成一個唯一索引值
        int uniqueNumber = context.getUniqueNumber();
        // Issue #709
        // <6> 繫結到 context 中
        if (o instanceof Map.Entry) {
            @SuppressWarnings("unchecked")
            Map.Entry<Object, Object> mapEntry = (Map.Entry<Object, Object>) o;
            /*
             * 和下面同理，只不過索引是 Map 的 key
             */
            applyIndex(context, mapEntry.getKey(), uniqueNumber);
            applyItem(context, mapEntry.getValue(), uniqueNumber);
        } else {
            /*
             * 繫結當前集合中當前元素的索引到當前解析 SQL 語句的上下文中
             *
             * 1. 'index' -> i
             *
             * 2. __frch_'index'_uniqueNumber -> i
             */
            applyIndex(context, i, uniqueNumber);
            /*
             * 繫結集合中當前元素的值到當前解析 SQL 語句的上下文中
             *
             * 1. 'item' -> o
             *
             * 2. __frch_'item'_uniqueNumber -> o
             *
             */
            applyItem(context, o, uniqueNumber);
        }
        /*
         * 再裝飾一下 PrefixedContext -> FilteredDynamicContext
         *
         * 前者進行字首的新增，第一個元素新增後設定為已新增標記，後續不在新增
         * 後者將<foreach />標籤內的"#{item}"或者"#{index}"替換成上面我們已經繫結的資料："#{__frch_'item'_uniqueNumber}"或者"#{__frch_'index'_uniqueNumber}"
         *
         * <7> 進行轉換，將<foreach />標籤內部定義的內容進行轉換
         */
        contents.apply(new FilteredDynamicContext(configuration, context, index, item, uniqueNumber));
        if (first) { // <8> 判斷 prefix 是否已經插入
            first = !((PrefixedContext) context).isPrefixApplied();
        }
        // <9> 恢復原始的 context 物件，因為目前 context 是裝飾器
        context = oldContext;
        i++;
    }
    // <10> 新增 close 到 SQL 中
    applyClose(context);
    // <11> 移除 index 和 item 對應的繫結
    context.getBindings().remove(item);
    context.getBindings().remove(index);
    return true;
}

private void applyIndex(DynamicContext context, Object o, int i) {
    if (index != null) {
        context.bind(index, o);
        context.bind(itemizeItem(index, i), o);
    }
}
private void applyItem(DynamicContext context, Object o, int i) {
    if (item != null) {
        context.bind(item, o);
        context.bind(itemizeItem(item, i), o);
    }
}
private void applyOpen(DynamicContext context) {
    if (open != null) {
        context.appendSql(open);
    }
}
private void applyClose(DynamicContext context) {
    if (close != null) {
        context.appendSql(close);
    }
}
private static String itemizeItem(String item, int i) {
    return ITEM_PREFIX + item + "_" + i;
}

1. 獲得需要遍歷的集合 Iterable 物件，呼叫ExpressionEvaluator的evaluateIterable(String expression, Object parameterObject)方法，根據表示式從引數中獲取集合物件

   1. 先通過OgnlCache根據Ognl表示式從上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面會講到
   2. 如果是Array陣列型別，則轉換成ArrayList集合後返回
   3. 如果是Map型別，則呼叫Map.Entry的集合

2. 如果定義了open屬性，則先拼接到SQL中

3. 開始遍歷集合 Iterable 物件，先記錄context原始物件為oldContext，因為接下來需要對其進行兩次裝飾，而這裡會再次進入

4. 建立一個PrefixedContext物件，裝飾context，主要是對集合中的每個元素新增separator分隔符

5. 生成一個唯一索引值，也就是DynamicContext的uniqueNumber++，這樣集合中每個元素都有一個唯一索引了

6. 將集合中的當前元素繫結到上下文中，會儲存以下資訊：

   applyIndex：如果配置了index屬性，則將當前元素的索引值繫結到上下文的ContextMap中，儲存兩個資料：

   1. 'index' -> i，其中'index'就是我們在<foreach />標籤中配置的index屬性，i就是當前元素在集合中的索引

   2. __frch_'index'_uniqueNumber -> i

   applyItem：如果配置了item屬性，則將當前元素繫結到上下文的ContextMap中，儲存兩個資料：

   1. 'item' -> o，其中'item'就是我們在<foreach />標籤中配置的item屬性，o就是當前元素物件
   2. __frch_'item'_uniqueNumber -> o

7. 再將PrefixedContext物件裝飾成FilteredDynamicContext物件

   然後應用<foreach />標籤內部的SqlNode節點們

   主要是替換我們在<foreach />標籤中定義的內容，替換成上面第6步繫結的資料的key值，這樣就可以獲取到該key對應的value了

   例如：將<foreach />標籤內的#{item}或者#{index}替換成第6步已經繫結的資料的key值#{__frch_'item'_uniqueNumber}或者#{__frch_'index'_uniqueNumber}，然後拼接到SQL中

8. 判斷是否新增了open字首，新增了則遍歷時不用再新增字首

9. 恢復原始的oldContext物件，因為目前context是裝飾器，然後繼續遍歷

10. 如果定義了close屬性，則拼接到SQL中

11. 從上下文的ContextMap中移除第6步繫結的第1條資料

第6步中，如果是Map型別，i對應的就是key值，o對應的就是value值，為什麼兩個方法都需要儲存第1條資料？

因為<foreach />標籤中可能還有其他的標籤，例如<if />標籤，它的判斷條件中可能需要用到當前元素或者索引值，而表示式中使用了'index'或者'item'，那麼就需要從上下文中獲取到對應的值了

那麼接下來我們來看看內部定義的兩個類：PrefixedContext和FilteredDynamicContext

PrefixedContext

ForeachNode的內部類，繼承了DynamicContext，用於應用<foreach />標籤時新增分隔符

重寫了appendSql方法，邏輯比較簡單，判斷是否需要新增分隔符，程式碼如下：

private class PrefixedContext extends DynamicContext {
    /**
     * 裝飾的 DynamicContext 物件
     */
    private final DynamicContext delegate;
    /**
     * 需要新增的字首
     */
    private final String prefix;
    /**
     * 是否已經新增
     */
    private boolean prefixApplied;

    public PrefixedContext(DynamicContext delegate, String prefix) {
        super(configuration, null);
        this.delegate = delegate;
        this.prefix = prefix;
        this.prefixApplied = false;
    }

    public boolean isPrefixApplied() {
        return prefixApplied;
    }

    @Override
    public Map<String, Object> getBindings() {
        return delegate.getBindings();
    }

    @Override
    public void bind(String name, Object value) {
        delegate.bind(name, value);
    }

    @Override
    public void appendSql(String sql) {
        if (!prefixApplied && sql != null && sql.trim().length() > 0) {
            delegate.appendSql(prefix);
            prefixApplied = true;
        }
        delegate.appendSql(sql);
    }

    @Override
    public String getSql() {
        return delegate.getSql();
    }

    @Override
    public int getUniqueNumber() {
        return delegate.getUniqueNumber();
    }
}

FilteredDynamicContext

ForeachNode的私有靜態內部類，繼承了DynamicContext，用於應用<foreach />標籤時替換內部的#{item}或者#{index}，

重寫了appendSql方法，程式碼如下：

private static class FilteredDynamicContext extends DynamicContext {
    /**
     * 裝飾的物件
     */
    private final DynamicContext delegate;
    /**
     * 集合中當前元素的索引
     */
    private final int index;
    /**
     * <foreach />定義的 index 屬性
     */
    private final String itemIndex;
    /**
     * <foreach />定義的 item 屬性
     */
    private final String item;

    public FilteredDynamicContext(Configuration configuration, DynamicContext delegate, String itemIndex, String item, int i) {
        super(configuration, null);
        this.delegate = delegate;
        this.index = i;
        this.itemIndex = itemIndex;
        this.item = item;
    }

    @Override
    public Map<String, Object> getBindings() {
        return delegate.getBindings();
    }

    @Override
    public void bind(String name, Object value) {
        delegate.bind(name, value);
    }

    @Override
    public String getSql() {
        return delegate.getSql();
    }

    @Override
    public void appendSql(String sql) {
        GenericTokenParser parser = new GenericTokenParser("#{", "}", content -> {
            // 如果在`<foreach />`標籤下的內容為通過item獲取元素，則替換成`__frch_'item'_uniqueNumber`
            String newContent = content.replaceFirst("^\\s*" + item + "(?![^.,:\\s])", itemizeItem(item, index));
            /*
             * 如果在`<foreach />`標籤中定義了index屬性，並且標籤下的內容為通過index獲取元素
             * 則替換成`__frch_'index'_uniqueNumber`
             */
            if (itemIndex != null && newContent.equals(content)) {
                newContent = content.replaceFirst("^\\s*" + itemIndex + "(?![^.,:\\s])", itemizeItem(itemIndex, index));
            }
            /*
             * 返回`#{__frch_'item'_uniqueNumber}`或者`#{__frch_'index'_uniqueNumber}`
             * 因為在前面已經將集合中的元素繫結在上下文的ContextMap中了，所以可以通過上面兩個key獲取到對應元素的值
             * 例如繫結的資料：
             * 1. __frch_'item'_uniqueNumber = 對應的元素值
             * 2. __frch_'index'_uniqueNumber = 對應的元素值的索引
             */
            return "#{" + newContent + "}";
        });

        delegate.appendSql(parser.parse(sql));
    }

    @Override
    public int getUniqueNumber() {
        return delegate.getUniqueNumber();
    }
}

1. 建立一個GenericTokenParser物件parser，用於處理 #{}

2. 建立一個TokenHandler處理器，大致的處理邏輯：

   1. 如果在<foreach />標籤下的內容為通過item獲取元素，則替換成__frch_'item'_uniqueNumber
   2. 如果在<foreach />標籤中定義了index屬性，並且標籤下的內容為通過index獲取元素，則替換成__frch_'index'_uniqueNumber
   3. 返回#{__frch_'item'_uniqueNumber}或者#{__frch_'index'_uniqueNumber}，因為在前面已經將集合中的元素繫結在上下文的ContextMap中了，所以可以通過上面兩個key獲取到對應元素的值

3. 呼叫parser進行解析，使用第2建立處理器進行處理，然後將轉換後的結果拼接到SQL中

IfSqlNode

org.apache.ibatis.scripting.xmltags.IfSqlNode：實現 SqlNode 介面，<if /> 標籤對應的 SqlNode 實現類，程式碼如下：

public class IfSqlNode implements SqlNode {
    /**
     * 表示式計算器
     */
	private final ExpressionEvaluator evaluator;
    /**
     * 判斷條件的表示式
     */
	private final String test;
    /**
     * MixedSqlNode，包含該<if />節點內所有資訊
     */
	private final SqlNode contents;

	public IfSqlNode(SqlNode contents, String test) {
		this.test = test;
		this.contents = contents;
		this.evaluator = new ExpressionEvaluator();
	}

	@Override
	public boolean apply(DynamicContext context) {
		// <1> 判斷是否符合條件
		if (evaluator.evaluateBoolean(test, context.getBindings())) {
			// <2> 解析該<if />節點中的內容
			contents.apply(context);
			return true;
		}
		// <3> 不符合
		return false;
	}
}

1. 呼叫ExpressionEvaluator的evaluateBoolean(String expression, Object parameterObject)方法，根據表示式從引數中獲取結果

   1. 先通過OgnlCache根據Ognl表示式從上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面會講到
   2. 如果是Boolean，則轉換成Boolean型別返回
   3. 如果是Number型別，則判斷是否不等於 0
   4. 其他類則判斷是否不等於null

2. 根據第1步的結果判斷是否應用<if />標籤內的SqlNode節點們

ChooseSqlNode

org.apache.ibatis.scripting.xmltags.ChooseSqlNode：實現 SqlNode 介面，<choose /> 標籤對應的 SqlNode 實現類，程式碼如下：

public class ChooseSqlNode implements SqlNode {
  /**
   * <otherwise /> 標籤對應的 SqlNode 節點
   */
  private final SqlNode defaultSqlNode;
  /**
   * <when /> 標籤對應的 SqlNode 節點陣列
   */
  private final List<SqlNode> ifSqlNodes;

  public ChooseSqlNode(List<SqlNode> ifSqlNodes, SqlNode defaultSqlNode) {
    this.ifSqlNodes = ifSqlNodes;
    this.defaultSqlNode = defaultSqlNode;
  }

  @Override
  public boolean apply(DynamicContext context) {
    // <1> 先判斷 <when /> 標籤中，是否有符合條件的節點。
    // 如果有，則進行應用。並且只因應用一個 SqlNode 物件
    for (SqlNode sqlNode : ifSqlNodes) {
      if (sqlNode.apply(context)) {
        return true;
      }
    }
    // <2> 再判斷  <otherwise /> 標籤，是否存在
    // 如果存在，則進行應用
    if (defaultSqlNode != null) {
      defaultSqlNode.apply(context);
      return true;
    }
    // <3> 返回都失敗
    return false;
  }
}

1. 先應用<choose />下的所有<when />標籤所對應的IfSqlNode，有一個應用成功則返回true
2. 如果所有的<when />都不滿足條件，則應用<otherwise />標籤下的內容所對應的SqlNode

StaticTextSqlNode

org.apache.ibatis.scripting.xmltags.StaticTextSqlNode：實現 SqlNode 介面，用於儲存靜態文字，邏輯比較簡單，直接拼接文字，程式碼如下：

public class StaticTextSqlNode implements SqlNode {
    /**
     * 靜態內容
     */
	private final String text;

	public StaticTextSqlNode(String text) {
		this.text = text;
	}

	@Override
	public boolean apply(DynamicContext context) {
	    // 直接往正在解析 SQL 語句的上下文的 SQL 中新增該內容
		context.appendSql(text);
		return true;
	}
}

TextSqlNode

org.apache.ibatis.scripting.xmltags.TextSqlNode：實現了 SqlNode 介面，用於處理${}，注入對應的值，程式碼如下：

public class TextSqlNode implements SqlNode {
  /**
   * 動態文字
   */
  private final String text;
  /**
   * 注入時的過濾器
   */
  private final Pattern injectionFilter;

  public TextSqlNode(String text) {
    this(text, null);
  }

  public TextSqlNode(String text, Pattern injectionFilter) {
    this.text = text;
    this.injectionFilter = injectionFilter;
  }

  public boolean isDynamic() {
    // <1> 建立 DynamicCheckerTokenParser 物件
    DynamicCheckerTokenParser checker = new DynamicCheckerTokenParser();
    // <2> 建立 GenericTokenParser 物件
    GenericTokenParser parser = createParser(checker);
    // <3> 執行解析，如果存在 '${ }'，則 checker 會設定 isDynamic 為true
    parser.parse(text);
    // <4> 判斷是否為動態文字
    return checker.isDynamic();
  }

  @Override
  public boolean apply(DynamicContext context) {
    // <1> 建立 BindingTokenParser 物件
    // <2> 建立 GenericTokenParser 物件
    GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
    // <3> 執行解析
    // <4> 將解析的結果，新增到 context 中
    context.appendSql(parser.parse(text));
    return true;
  }

  private GenericTokenParser createParser(TokenHandler handler) {
    return new GenericTokenParser("${", "}", handler);
  }

  private static class BindingTokenParser implements TokenHandler {

    private DynamicContext context;
    /**
     * 注入時的過濾器
     */
    private Pattern injectionFilter;

    public BindingTokenParser(DynamicContext context, Pattern injectionFilter) {
      this.context = context;
      this.injectionFilter = injectionFilter;
    }

    @Override
    public String handleToken(String content) {
      // 從上下文中獲取入參物件，在DynamicContext的構造方法中可以看到為什麼可以獲取到
      Object parameter = context.getBindings().get("_parameter");
      if (parameter == null) {
        context.getBindings().put("value", null);
      } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
        context.getBindings().put("value", parameter);
      }
      // 使用 OGNL 表示式，獲得對應的值
      Object value = OgnlCache.getValue(content, context.getBindings());
      String srtValue = value == null ? "" : String.valueOf(value); // issue #274 return "" instead of "null"
      // 使用過濾器進行過濾
      checkInjection(srtValue);
      return srtValue;
    }

    private void checkInjection(String value) {
      if (injectionFilter != null && !injectionFilter.matcher(value).matches()) {
        throw new ScriptingException("Invalid input. Please conform to regex" + injectionFilter.pattern());
      }
    }
  }
}

在XML檔案中編寫SQL語句時，如果使用到了${}作為變數時，那麼會生成TextSqlNode對象，可以回看XMLScriptBuilder的parseDynamicTags()方法

在MyBatis處理SQL語句時就會將${}進行替換成對應的引數，存在SQL隱碼攻擊的安全性問題

而#{}就不一樣了，MyBatis會將其替換成?佔位符，通過java.sql.PreparedStatement進行預編譯處理，不存在上面的問題

1. 建立GenericTokenParser物件parser，用於處理${}，設定的Token處理器為BindingTokenParser
2. 執行解析，我們可以看到BindingTokenParser的handleToken(String content)方法
   1. 從上下文中獲取入參物件，在DynamicContext的構造方法中可以看到為什麼可以獲取到
   2. 在將入參物件繫結到上下文中，設定key為"value"，為什麼這麼做呢？？沒有仔細探究，可能跟OGNL相關，感興趣的小夥伴可以探討一下?
   3. 使用 OGNL 表示式，從上下文中獲得${}中內容對應的值，如果為null則設定為空字串
   4. 使用注入過濾器對注入的值過濾
3. 將解析後的結果拼接到SQL中

MixedSqlNode

org.apache.ibatis.scripting.xmltags.MixedSqlNode：實現 SqlNode 介面，用於儲存多個SqlNode物件

因為一個SQL語句會被解析成多個SqlNode，且內部還會巢狀多個，所以使用MixedSqlNode進行儲存，程式碼如下：

public class MixedSqlNode implements SqlNode {
  /**
   * 動態節點集合
   */
	private final List<SqlNode> contents;

	public MixedSqlNode(List<SqlNode> contents) {
		this.contents = contents;
	}

	@Override
	public boolean apply(DynamicContext context) {
	  // 逐個應用
		contents.forEach(node -> node.apply(context));
		return true;
	}
}

OgnlCache

org.apache.ibatis.scripting.xmltags.OgnlCache：用於處理Ognl表示式

在上面SqlNode的apply方法中，使用到的邏輯判斷時獲取表示式的結果則需要通過OgnlCache來進行解析

對OGNL不瞭解的小夥伴可以看下這篇文章：Ognl表示式基本原理和使用方法

程式碼如下：

public final class OgnlCache {

	/**
	 * OgnlMemberAccess 單例，用於修改某個物件的成員為可訪問
	 */
	private static final OgnlMemberAccess MEMBER_ACCESS = new OgnlMemberAccess();
	/**
	 * OgnlClassResolver 單例，用於建立 Class 物件
	 */
	private static final OgnlClassResolver CLASS_RESOLVER = new OgnlClassResolver();
	/**
	 * 表示式的快取的對映
	 *
	 * KEY：表示式 VALUE：表示式的快取 @see #parseExpression(String)
	 */
	private static final Map<String, Object> expressionCache = new ConcurrentHashMap<>();

	private OgnlCache() {
		// Prevent Instantiation of Static Class
	}

	public static Object getValue(String expression, Object root) {
		try {
            /*
             * <1> 建立 OgnlContext 物件，設定 OGNL 的成員訪問器和類解析器，設定根元素為 root 物件
             * 這裡是呼叫 OgnlContext 的s etRoot 方法直接設定根元素，可以通過 'user.id' 獲取結果
             * 如果是通過 put 方法新增的物件，則取值時需要使用'#'，例如 '#user.id'
             */
            Map context = Ognl.createDefaultContext(root, MEMBER_ACCESS, CLASS_RESOLVER, null);
            /*
             * <2> expression 轉換成 Ognl 表示式
             * <3> 根據 Ognl 表示式獲取結果
             */
			return Ognl.getValue(parseExpression(expression), context, root);
		} catch (OgnlException e) {
			throw new BuilderException("Error evaluating expression '" + expression + "'. Cause: " + e, e);
		}
	}

  /**
   * 根據表示式構建一個 Ognl 表示式
   *
   * @param expression 表示式，例如<if test="user.id &gt; 0"> </if>，那這裡傳入的就是 "user.id &gt; 0"
   * @return Ognl 表示式
   * @throws OgnlException 異常
   */
  private static Object parseExpression(String expression) throws OgnlException {
    Object node = expressionCache.get(expression);
    if (node == null) {
      node = Ognl.parseExpression(expression);
      expressionCache.put(expression, node);
    }
    return node;
  }

}

getValue方法：根據Ognl表示式從Object中獲取結果

1. 建立 OgnlContext 物件，設定 OGNL 的成員訪問器和類解析器，設定根元素為 root 物件

2. 將建立 expression 轉換成 Ognl 表示式，快取起來

3. 根據 Ognl 表示式從 root 物件中獲取結果

總結

本文講述的是XML對映檔案中的<select /> <insert /> <update /> <delete />節點內的SQL語句如何被解析的

在XMLLanguageDriver語言驅動類中，通過XMLScriptBuilder對該到節點的內容進行解析，建立相應的SqlSource資源物件

在其解析的過程會根據不同的NodeHandler節點處理器對MyBatis自定義的標籤（<if /> <foreach />等）進行處理，生成相應的SqlNode物件，最後將所有的SqlNode物件存放在MixedSqlNode中

解析的過程中會判斷是否為動態的SQL語句，包含了MyBatis自定義的標籤或者使用了${}都是動態的SQL語句，動態的SQL語句建立DynamicSqlSource物件，否則建立RawSqlSource物件

那麼關於SqlSource是什麼其實這裡還不是特別瞭解，由於其涉及到的篇幅並不少，所以另起一篇文件《MyBatis初始化（四）之SQL初始化（下）》進行分析

參考文章：芋道原始碼《精盡 MyBatis 原始碼分析》