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

月圓吖發表於2020-11-23

該系列文件是本人在學習 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初始化過程中，大致會有以下幾個步驟：

建立Configuration全域性配置物件，會往TypeAliasRegistry別名註冊中心新增Mybatis需要用到的相關類，並設定預設的語言驅動類為XMLLanguageDriver
載入mybatis-config.xml配置檔案、Mapper介面中的註解資訊和XML對映檔案，解析後的配置資訊會形成相應的物件並儲存到Configuration全域性配置物件中
構建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);
}

定義了三個方法：

createParameterHandler：獲取 ParameterHandler 引數處理器物件
createSqlSource：建立 SqlSource 物件，解析 Mapper XML 配置的 Statement 標籤中，即 <select /> <update /> <delete /> <insert />
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介面：

建立 DefaultParameterHandler 預設引數處理器並返回
解析 XML 對映檔案中的 SQL，通過建立 XMLScriptBuilder 物件，呼叫其 parseScriptNode() 方法解析
解析註解定義的 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;
}

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

獲取<bind />標籤的name和value屬性
根據這些屬性建立一個 VarDeclSqlNode 物件
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<if />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
獲得 prefix、prefixOverrides、suffix、suffixOverrides 屬性
根據上面獲取到的屬性建立TrimSqlNode物件
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<where />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
建立WhereSqlNode物件，該物件繼承了TrimSqlNode，自定義字首（WHERE）和需要刪除的字首（AND、OR等）
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<set />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
建立SetSqlNode物件，該物件繼承了TrimSqlNode，自定義字首（SET）和需要刪除的字首和字尾（,）
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<foreach />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
獲得 collection、item、index、open、close、separator 屬性
根據這些屬性建立ForEachSqlNode物件
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<if />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
獲得 test 屬性
根據這個屬性建立IfSqlNode物件
新增到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);
    }
}

繼續呼叫parseDynamicTags方法解析<otherwise />標籤內部的子標籤節點，巢狀解析，生成MixedSqlNode物件
新增到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;
    }
}

先逐步處理<choose />標籤的<when /> 和 <otherwise />子標籤們，通過組合 IfHandler 和 OtherwiseHandler 兩個處理器，實現對子節點們的解析
如果存在<otherwise />子標籤，則丟擲異常
根據這些屬性建立ChooseSqlNode物件
新增到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`處理節點時需要用到，生成唯一陣列作為集合中每個元素的索引（作為字尾）

初始化bindings引數，建立 ContextMap 物件
1. 根據入參轉換成MetaObject物件
2. 在靜態程式碼塊中，設定OGNL的屬性訪問器，OgnlRuntime 是 OGNL 庫中的類，設定ContextMap對應的訪問器是ContextAccessor類
往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 物件

在重寫的getProperty方法中，先從 ContextMap 裡面獲取屬性值（可以回過去看下ContextMap的get方法）
沒有獲取到則獲取 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;
	}
}

通過OGNL表示式expression從DynamicContext上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面講到
將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;
}

通過裝飾器模式將context裝飾成FilteredDynamicContext物件
因為<trim />標籤中定義了內容或者其他標籤，都會解析成相應的SqlNode，儲存在contents中（MixedSqlNode）

所以這裡需要先應用內部的SqlNode，轉換後的SQL會先儲存在FilteredDynamicContext中
對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;
}

獲得需要遍歷的集合 Iterable 物件，呼叫ExpressionEvaluator的evaluateIterable(String expression, Object parameterObject)方法，根據表示式從引數中獲取集合物件
1. 先通過OgnlCache根據Ognl表示式從上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面會講到
2. 如果是Array陣列型別，則轉換成ArrayList集合後返回
3. 如果是Map型別，則呼叫Map.Entry的集合
如果定義了open屬性，則先拼接到SQL中
開始遍歷集合 Iterable 物件，先記錄context原始物件為oldContext，因為接下來需要對其進行兩次裝飾，而這裡會再次進入
建立一個PrefixedContext物件，裝飾context，主要是對集合中的每個元素新增separator分隔符
生成一個唯一索引值，也就是DynamicContext的uniqueNumber++，這樣集合中每個元素都有一個唯一索引了
將集合中的當前元素繫結到上下文中，會儲存以下資訊：

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
再將PrefixedContext物件裝飾成FilteredDynamicContext物件

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

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

例如：將<foreach />標籤內的#{item}或者#{index}替換成第6步已經繫結的資料的key值#{__frch_'item'_uniqueNumber}或者#{__frch_'index'_uniqueNumber}，然後拼接到SQL中
判斷是否新增了open字首，新增了則遍歷時不用再新增字首
恢復原始的oldContext物件，因為目前context是裝飾器，然後繼續遍歷
如果定義了close屬性，則拼接到SQL中
從上下文的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();
    }
}

建立一個GenericTokenParser物件parser，用於處理 #{}
建立一個TokenHandler處理器，大致的處理邏輯：
1. 如果在<foreach />標籤下的內容為通過item獲取元素，則替換成__frch_'item'_uniqueNumber
2. 如果在<foreach />標籤中定義了index屬性，並且標籤下的內容為通過index獲取元素，則替換成__frch_'index'_uniqueNumber
3. 返回#{__frch_'item'_uniqueNumber}或者#{__frch_'index'_uniqueNumber}，因為在前面已經將集合中的元素繫結在上下文的ContextMap中了，所以可以通過上面兩個key獲取到對應元素的值
呼叫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;
	}
}

呼叫ExpressionEvaluator的evaluateBoolean(String expression, Object parameterObject)方法，根據表示式從引數中獲取結果
1. 先通過OgnlCache根據Ognl表示式從上下文的ContextMap中獲取轉換後的結果，OgnlCache在後面會講到
2. 如果是Boolean，則轉換成Boolean型別返回
3. 如果是Number型別，則判斷是否不等於 0
4. 其他類則判斷是否不等於null
根據第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;
  }
}

先應用<choose />下的所有<when />標籤所對應的IfSqlNode，有一個應用成功則返回true
如果所有的<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進行預編譯處理，不存在上面的問題

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

建立 OgnlContext 物件，設定 OGNL 的成員訪問器和類解析器，設定根元素為 root 物件
將建立 expression 轉換成 Ognl 表示式，快取起來
根據 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 原始碼分析》

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

MyBatis的初始化

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

LanguageDriver

XMLLanguageDriver

RawLanguageDriver

XMLScriptBuilder

構造方法

parseScriptNode方法

parseDynamicTags方法

NodeHandler

BindHandler

TrimHandler

WhereHandler

SetHandler

ForEachHandler

IfHandler

OtherwiseHandler

ChooseHandler

DynamicContext

構造方法

ContextMap

ContextAccessor

SqlNode

VarDeclSqlNode

TrimSqlNode

構造方法

apply方法

FilteredDynamicContext

WhereSqlNode

SetSqlNode

ForeachNode

構造方法

apply方法

PrefixedContext

FilteredDynamicContext

IfSqlNode

ChooseSqlNode

StaticTextSqlNode

TextSqlNode

MixedSqlNode

OgnlCache

總結

相關文章