MyBatis 源碼分析 - MyBatis初始化（四）之 SQL 初始化（下）

本文轉載自查看原文 2020-11-24 08:58 546 MyBatis/ 源碼解析/ 精盡MyBatis源碼分析

參考知識星球中 芋道源碼 星球的源碼解析，一個活躍度非常高的 Java 技術社群，感興趣的小伙伴可以加入 芋道源碼 星球，一起學習😄

該系列文檔是本人在學習 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的初始化

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

創建Configuration全局配置對象，會往TypeAliasRegistry別名注冊中心添加Mybatis需要用到的相關類，並設置默認的語言驅動類為XMLLanguageDriver
加載mybatis-config.xml配置文件、Mapper接口中的注解信息和XML映射文件，解析后的配置信息會形成相應的對象並保存到Configuration全局配置對象中
構建DefaultSqlSessionFactory對象，通過它可以創建DefaultSqlSession對象，MyBatis中SqlSession的默認實現類

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

由於在MyBatis的初始化過程中去解析Mapper接口與XML映射文件涉及到的篇幅比較多，XML映射文件的解析過程也比較復雜，所以才分成了后面三個模塊，逐步分析，這樣便於理解

初始化（四）之SQL初始化（下）

在上一篇文檔中詳細地講述了MyBatis在解析<select /> <insert /> <update /> <delete /> 節點的過程中，是如何解析SQL語句的，如何實現動態SQL語句的，最終會生成一個org.apache.ibatis.mapping.SqlSource對象的，那么接下來我們來看看SqlSource到底是什么

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

主要涉及到的類：

org.apache.ibatis.builder.SqlSourceBuilder：繼承了BaseBuilder抽象類，SqlSource構建器，負責將SQL語句中的#{}替換成相應的?占位符，並獲取該?占位符對應的 ParameterMapping對象
org.apache.ibatis.builder.ParameterExpression：繼承了HashMap<String, String>，參數表達式處理器，在SqlSourceBuilder處理#{}的內容時，需要通過其解析成key-value鍵值對
org.apache.ibatis.mapping.ParameterMapping：保存#{}中配置的屬性參數信息
org.apache.ibatis.mapping.SqlSource：SQL 資源接口，用於創建BoundSql對象（包含可執行的SQL語句與參數信息）
org.apache.ibatis.mapping.BoundSql：用於數據庫可執行的SQL語句的最終封裝對象
org.apache.ibatis.scripting.defaults.DefaultParameterHandler：實現了ParameterHandler接口，用於將入參設置到java.sql.PreparedStatement預編譯對象中

用於將入參設置到java.sql.PreparedStatement預編譯對象中

我們先來回顧一下org.apache.ibatis.scripting.xmltags.XMLScriptBuilder的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;
}

如果是動態 SQL 語句，使用了 MyBatis 的自定義標簽（<if /> <foreach />等）或者使用了 ${} 都是動態 SQL 語句，則會創建DynamicSqlSource對象
否則就是靜態 SQL 語句，創建 RawSqlSource 對象

SqlSource接口的實現類如下圖所示：

SqlSourceBuilder

org.apache.ibatis.builder.SqlSourceBuilder：繼承了BaseBuilder抽象類，SqlSource構建器，負責將SQL語句中的#{}替換成相應的?占位符，並獲取該?占位符對應的 org.apache.ibatis.mapping.ParameterMapping 對象

構造方法

public class SqlSourceBuilder extends BaseBuilder {
    
	private static final String PARAMETER_PROPERTIES = "javaType,jdbcType,mode,numericScale,resultMap,typeHandler,jdbcTypeName";

	public SqlSourceBuilder(Configuration configuration) {
		super(configuration);
	}
}

其中PARAMETER_PROPERTIES字符串定義了#{}中支持定義哪些屬性，在拋異常的時候用到

parse方法

解析原始的SQL（僅包含#{}定義的參數），轉換成StaticSqlSource對象

因為在DynamicSqlSource調用該方法前會將MixedSqlNode進行處理，調用其apply方法進行應用，根據DynamicContext上下文對MyBatis的自定義標簽或者包含${}的SQL生成的SqlNode進行邏輯處理或者注入值，生成一個SQL（僅包含#{}定義的參數）

代碼如下：

/**
* 執行解析原始 SQL ，成為 SqlSource 對象
*
* @param originalSql          原始 SQL
* @param parameterType        參數類型
* @param additionalParameters 上下文的參數集合，包含附加參數集合（通過 <bind /> 標簽生成的，或者`<foreach />`標簽中的集合的元素）
*                             RawSqlSource傳入空集合
*                             DynamicSqlSource傳入 {@link org.apache.ibatis.scripting.xmltags.DynamicContext#bindings} 集合
* @return SqlSource 對象
*/
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
    // <1> 創建 ParameterMappingTokenHandler 對象
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
    // <2> 創建 GenericTokenParser 對象
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    /*
     * <3> 執行解析
     * 將我們在 SQL 定義的所有占位符 #{content} 都替換成 ?
     * 並生成對應的 ParameterMapping 對象保存在 ParameterMappingTokenHandler 中
     */
    String sql = parser.parse(originalSql);
    // <4> 創建 StaticSqlSource 對象
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

該方法的入參originalSql為原始的SQL，也就是其所有的SqlNode節點已經應用了，也就是都調用了apply方法

包含的${}也已經注入了對應的值，所以這里只剩#{}定義的入參了

創建ParameterMappingTokenHandler處理器對象handler
創建GenericTokenParser對象，用於處理#{}中的內容，通過handler將其轉換成?占位符，並創建對應的ParameterMapping對象
執行解析，獲取最終的 SQL 語句
創建StaticSqlSource對象

ParameterMappingTokenHandler

org.apache.ibatis.builder.SqlSourceBuilder的內部類，用於解析#{}的內容，創建ParameterMapping對象，並將其替換成?占位符

代碼如下：

private static class ParameterMappingTokenHandler extends BaseBuilder implements TokenHandler {

    /**
     * 我們在 SQL 語句中定義的占位符對應的 ParameterMapping 數組，根據順序來的
     */
    private List<ParameterMapping> parameterMappings = new ArrayList<>();
    /**
     * 參數類型
     */
    private Class<?> parameterType;
    /**
     * additionalParameters 參數的對應的 MetaObject 對象
     */
    private MetaObject metaParameters;

    public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType, Map<String, Object> additionalParameters) {
        super(configuration);
        this.parameterType = parameterType;
        // 創建 additionalParameters 參數的對應的 MetaObject 對象
        this.metaParameters = configuration.newMetaObject(additionalParameters);
    }

    public List<ParameterMapping> getParameterMappings() {
        return parameterMappings;
    }

    @Override
    public String handleToken(String content) {
        // <1> 構建 ParameterMapping 對象，並添加到 parameterMappings 中
        parameterMappings.add(buildParameterMapping(content));
        // <2> 返回 ? 占位符
        return "?";
    }

    /**
     * 根據內容構建一個 ParameterMapping 對象
     *
     * @param content 我們在 SQL 語句中定義的占位符
     * @return ParameterMapping 對象
     */
    private ParameterMapping buildParameterMapping(String content) {
        // <1> 將字符串解析成 key-value 鍵值對保存
        // 其中有一個key為"property"，value就是對應的屬性名稱
        Map<String, String> propertiesMap = parseParameterMapping(content);
        // <2> 獲得屬性的名字和類型
        String property = propertiesMap.get("property"); // 名字
        Class<?> propertyType; // 類型
        if (metaParameters.hasGetter(property)) { // issue #448 get type from additional params
            propertyType = metaParameters.getGetterType(property);
        } else if (typeHandlerRegistry.hasTypeHandler(parameterType)) { // 有對應的類型處理器，例如java.lang.string
            propertyType = parameterType;
        } else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) { // 設置的 Jdbc Type 是游標
            propertyType = java.sql.ResultSet.class;
        } else if (property == null || Map.class.isAssignableFrom(parameterType)) { // 是 Map 集合
            propertyType = Object.class;
        } else { // 類對象
            MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
            if (metaClass.hasGetter(property)) {
              // 通過反射獲取到其對應的 Java Type
                propertyType = metaClass.getGetterType(property);
            } else {
                propertyType = Object.class;
            }
        }
        // <3> 創建 ParameterMapping.Builder 構建者對象
        ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);
        // <3.1> 初始化 ParameterMapping.Builder 對象的屬性
        Class<?> javaType = propertyType;
        String typeHandlerAlias = null;
        // 遍歷 SQL 配置的占位符信息，例如這樣配置："name = #{name, jdbcType=VARCHAR}"
        for (Map.Entry<String, String> entry : propertiesMap.entrySet()) {
            String name = entry.getKey();
            String value = entry.getValue();
            if ("javaType".equals(name)) {
                javaType = resolveClass(value);
                builder.javaType(javaType);
            } else if ("jdbcType".equals(name)) {
                builder.jdbcType(resolveJdbcType(value));
            } else if ("mode".equals(name)) {
                builder.mode(resolveParameterMode(value));
            } else if ("numericScale".equals(name)) {
                builder.numericScale(Integer.valueOf(value));
            } else if ("resultMap".equals(name)) {
                builder.resultMapId(value);
            } else if ("typeHandler".equals(name)) {
                typeHandlerAlias = value;
            } else if ("jdbcTypeName".equals(name)) {
                builder.jdbcTypeName(value);
            } else if ("property".equals(name)) {
                // Do Nothing
            } else if ("expression".equals(name)) {
                throw new BuilderException("Expression based parameters are not supported yet");
            } else {
                throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}.  Valid properties are " + PARAMETER_PROPERTIES);
            }
        }
        // <3.2> 如果 TypeHandler 類型處理器的別名非空
        if (typeHandlerAlias != null) {
            builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
        }
        // <3.3> 創建 ParameterMapping 對象
        return builder.build();
    }

    private Map<String, String> parseParameterMapping(String content) {
        try {
            return new ParameterExpression(content);
        } catch (BuilderException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new BuilderException("Parsing error was found in mapping #{" + content
                    + "}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} ", ex);
        }
    }
}

構造方法：創建additionalParameters對應的MetaObject對象，便於操作上下文的參數集合，包含附加參數集合（通過 <bind /> 標簽生成的，或者<foreach />標簽中的集合的元素）

handleToken(String content)方法：

調用buildParameterMapping(content)方法，解析#{}的內容創建ParameterMapping對象
直接返回?占位符

buildParameterMapping(content)方法：

將字符串解析成 key-value 鍵值對，通過org.apache.ibatis.builder.ParameterExpression進行解析，其中有一個key為"property"，value就是對應的屬性名稱
獲得屬性的名字和類型
創建ParameterMapping.Builder構建者對象，設置參數的名稱與Java Type
1. 將上面第1步解析到key-value鍵值對設置到Builder中
2. 如果TypeHandler類型處理器的別名非空，則嘗試獲取其對應的類型處理器並設置到Builder中
3. 通過Builder創建ParameterMapping對象，如果沒有配置TypeHandler類型處理器，則根據參數Java Type和Jdbc Type從TypeHandlerRegistry注冊中心獲取並賦值到該對象中

ParameterExpression

org.apache.ibatis.builder.ParameterExpression：繼承了HashMap<String, String>，參數表達式處理器，在ParameterMappingTokenHandler處理#{}的內容時需要通過其解析成key-value鍵值對

構造方法：

public class ParameterExpression extends HashMap<String, String> {

	private static final long serialVersionUID = -2417552199605158680L;

    /**
     * 從類的注釋中可以看出我們可以這樣定義占位符
     * 1. #{propertyName, javaType=string, jdbcType=VARCHAR}
     * 2. #{(expression), javaType=string, jdbcType=VARCHAR}
     *
     * @param expression 我們定義的占位符表達式
     */
	public ParameterExpression(String expression) {
		parse(expression);
	}
}

在構造函數中調用其parse(String expression)方法

private void parse(String expression) {
    // 跳過前面的非法字符（ASCII 小於33），目的是去除空格，還有非法的字符，可以參照 ASCII 字符代碼表看看
    int p = skipWS(expression, 0);
    if (expression.charAt(p) == '(') {
        // 屬於第二種方式，我在官方沒有看到介紹，這里也不做介紹了
        expression(expression, p + 1);
    } else {
        // 將整個字符串轉換成 key-value 保存至 Map.Entry
        property(expression, p);
    }
}

先出去前面的空格或者非法字符，然后調用property(String expression, int left)方法

// #{propertyName, javaType=string, jdbcType=VARCHAR}
private void property(String expression, int left) {
    if (left < expression.length()) {
        // 獲取到逗號或者冒號第一個位置，也就是分隔符
        int right = skipUntil(expression, left, ",:");
    	// 從內容中截取第一個逗號前面的字符串，也上面第 1 種方式的 "name"
    	put("property", trimmedStr(expression, left, right));
    	// 解析字符串一個逗號后面的字符串，也就是該屬性的相關配置
    	jdbcTypeOpt(expression, right);
    }
}

如果left開始位置小於字符串的長度，那么開始解析

調用skipUntil方法，獲取從left開始,或者:第一個位置，也就是分隔符的位置
這里第一次進入的話就會先獲取第一個,的位置，那么調用trimmedStr方法截取前面的字符串，也就是屬性名稱，然后存放一個鍵值對（key為property，value為屬性名稱）
調用jdbcTypeOpt(String expression, int p)方法，繼續解析后面的字符串，也就是該屬性的相關配置

private void jdbcTypeOpt(String expression, int p) {
    p = skipWS(expression, p);
    if (p < expression.length()) {
        if (expression.charAt(p) == ':') { // 屬於上面第 2 種方式，不做分析
            jdbcType(expression, p + 1);
        } else if (expression.charAt(p) == ',') {
            // 將第一個 , 后面的字符串解析成 key-value 保存
            option(expression, p + 1);
        } else {
            throw new BuilderException("Parsing error in {" + expression + "} in position " + p);
        }
    }
}

如果p（第一個,的位置）后面還有字符串

則調用option(String expression, int p)方法將一個,后面的字符串解析成key-value鍵值對保存

/**
 * 將字符串生成轉換成key-value的形式
 * 例如 expression = "name, jdbcType = VARCHAR, javaType = string" 設置 p = 6
 * 這樣將會往 Map 中保存兩個鍵值對："jdbcType"->"VARCHAR" "javaType"->"string"
 *
 * @param expression 字符串
 * @param p 字符串從哪個位置轉換
 */
private void option(String expression, int p) {
    int left = skipWS(expression, p);
    if (left < expression.length()) {
        // 獲取 = 的位置
        int right = skipUntil(expression, left, "=");
        // 截取 = 前面的字符串，對應的 key
        String name = trimmedStr(expression, left, right);
        left = right + 1;
        // 獲取 , 的位置
        right = skipUntil(expression, left, ",");
        // 截取 = 到 , 之間的字符串，也就是對應的 value
        String value = trimmedStr(expression, left, right);
        // 將 key-value 保存
        put(name, value);
        // 繼續遍歷后面的字符串
        option(expression, right + 1);
    }
}

逐步解析，將字符串解析成key-value鍵值對保存，這里保存的都是屬性的相關配置，例如JdbcType配置

ParameterMapping

org.apache.ibatis.mapping.ParameterMapping：保存#{}中配置的屬性參數信息，一個普通的實體類，代碼如下：

/**
 * SQL 語句中 ? 占位符對應的對象
 *
 * @author Clinton Begin
 */
public class ParameterMapping {

  /**
   * 全局配置對象
   */
  private Configuration configuration;
  /**
   * 屬性名稱
   */
  private String property;
  /**
   * 參數模式
   */
  private ParameterMode mode;
  /**
   * 屬性的 Java Type
   * 一般可以直接通過入參對象知道，但是如果入參是 Map，需要顯式指定，以確保使用正確的類型處理器
   */
  private Class<?> javaType = Object.class;
  /**
   * 屬性的 Jdbc Type
   */
  private JdbcType jdbcType;
  /**
   * 對於數值類型，指定小數點后保留的位數
   */
  private Integer numericScale;
  /**
   * 類型處理器
   */
  private TypeHandler<?> typeHandler;
  /**
   * 如果 {@link mode} 為 OUT 或者 INOUT，且{@link jdbcType} 為 CURSOR（也就是 Oracle 的 REFCURSOR）
   * 必須指定一個 resultMap 引用來將結果集 ResultMap 映射到參數的類型上
   */
  private String resultMapId;
  /**
   * Jdbc Type 名稱
   */
  private String jdbcTypeName;
  private String expression;

  private ParameterMapping() {
  }
}

SqlSource

org.apache.ibatis.mapping.SqlSource：SQL 資源接口，用於創建BoundSql對象（包含可執行的SQL語句與參數信息），代碼如下：

/**
 * Represents the content of a mapped statement read from an XML file or an annotation.
 * It creates the SQL that will be passed to the database out of the input parameter received from the user.
 *
 * @author Clinton Begin
 */
public interface SqlSource {

    /**
     * 根據傳入的參數對象，返回 BoundSql 對象
     *
     * @param parameterObject 參數對象
     * @return BoundSql 對象
     */
    BoundSql getBoundSql(Object parameterObject);
}

StaticSqlSource

org.apache.ibatis.builder.StaticSqlSource：實現 SqlSource 接口，靜態的 SqlSource 實現類，代碼如下：

public class StaticSqlSource implements SqlSource {

	/**
	 * 解析后的 SQL 語句，數據庫能執行
	 */
	private final String sql;
	/**
	 * 上面 SQL 語句中占位符對應的 ParameterMapping 參數集合
	 */
	private final List<ParameterMapping> parameterMappings;
    /**
     * 全局配置對象
     */
	private final Configuration configuration;

	public StaticSqlSource(Configuration configuration, String sql) {
		this(configuration, sql, null);
	}

	public StaticSqlSource(Configuration configuration, String sql, List<ParameterMapping> parameterMappings) {
		this.sql = sql;
		this.parameterMappings = parameterMappings;
		this.configuration = configuration;
	}

	@Override
	public BoundSql getBoundSql(Object parameterObject) {
		return new BoundSql(configuration, sql, parameterMappings, parameterObject);
	}

}

在SqlSourceBuilder構建的SqlSource類型就是StaticSqlSource，用於獲取最終的靜態 SQL 語句

RawSqlSource

org.apache.ibatis.scripting.defaults.RawSqlSource：實現了SqlSource接口，靜態SQL語句對應的SqlSource對象，用於創建靜態 SQL 資源，代碼如下：

public class RawSqlSource implements SqlSource {

  private final SqlSource sqlSource;

  public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
    /*
     * 因為靜態的 SQL 語句可以直接拿來解析，不需要根據入參就可以應用
     * 所以調用 getSql 方法獲取靜態的 SQL 語句
     */
    this(configuration, getSql(configuration, rootSqlNode), parameterType);
  }

  public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> clazz = parameterType == null ? Object.class : parameterType;
    // 通過 SqlSourceBuilder 將這個靜態的 SQL 進行轉換，變量替換成 ? 占位符，並生成對應的 ParameterMapping 集合
    sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<>());
  }

  private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
    DynamicContext context = new DynamicContext(configuration, null);
    // 調用 StaticTextSqlNode 將 SQL 語句拼接起來
    rootSqlNode.apply(context);
    return context.getSql();
  }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    return sqlSource.getBoundSql(parameterObject);
  }
}

在構造函數中我們可以看到，會先調用getSql方法直接創建SqlSource

因為靜態的 SQL 語句，不需要根據入參來進行邏輯上的判斷處理，所以這里在構造函數中就先初始化好 SqlSource，后續需要調用Mapper接口執行SQL的時候就減少了一定的時間

getSql方法：

創建一個上下文對象DynamicContext，入參信息為null
調用StaticTextSqlNode的apply方法，將所有的SQL拼接在一起
返回拼接好的SQL語句

構造方法：

創建SqlSourceBuilder構建對象sqlSourceParser
調用sqlSourceParser的parse方法對該SQL語句進行轉換，#{}全部替換成?占位符，並創建對應的ParameterMapping對象
第2步返回的StaticSqlSource對象設置到自己的sqlSource屬性中

getBoundSql方法：直接通過StaticSqlSource創建BoundSql對象

DynamicSqlSource

org.apache.ibatis.scripting.defaults.DynamicSqlSource：實現了SqlSource接口，動態SQL語句對應的SqlSource對象，用於創建靜態 SQL 資源，代碼如下：

public class DynamicSqlSource implements SqlSource {

	private final Configuration configuration;
	/**
	 * 根 SqlNode 對象
	 */
	private final SqlNode rootSqlNode;

	public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
		this.configuration = configuration;
		this.rootSqlNode = rootSqlNode;
	}

	@Override
	public BoundSql getBoundSql(Object parameterObject) {
		// <1> 創建本次解析的動態 SQL 語句的上下文
		DynamicContext context = new DynamicContext(configuration, parameterObject);
		// <2> 根據上下文應用整個 SqlNode
		rootSqlNode.apply(context);
		// <3> 創建 SqlSourceBuilder 對象
		SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
		Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
        // <4> 通過 SqlSourceBuilder 將應用后的 SQL 進行轉換，變量替換成 ? 占位符，並生成對應的 ParameterMapping 集合
		SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
		// <5> 創建 BoundSql 對象
		BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
		// <6> 添加附加參數到 BoundSql 對象中，因為上一步創建的`BoundSql`對象時候傳入的僅是入參信息，沒有添加附加參數
		context.getBindings().forEach(boundSql::setAdditionalParameter);
		return boundSql;
	}
}

在構造函數中僅僅是賦值，不像RawSqlSource的構造函數一樣直接可創建對應的SqlSource對象，因為動態SQL語句需要根據入參信息，來解析SqlNode節點，所以這里在getBoundSql方法中每次都會創建StaticSqlSource對象

getBoundSql方法：

創建本次解析的動態 SQL 語句的上下文，設置入參信息
根據上下文應用整個 SqlNode，內部包含的所有SqlNode都會被應用，最終解析后的SQL會保存上下文中
創建 SqlSourceBuilder 構建對象sqlSourceParser
調用sqlSourceParser的parse方法對第2步解析后的SQL語句進行轉換，#{}全部替換成?占位符，並創建對應的ParameterMapping對象
通過第4步返回的StaticSqlSource對象創建BoundSql對象
添加附加參數到BoundSql對象中，因為上一步創建的BoundSql對象時候傳入的僅是入參信息，沒有添加附加參數（通過<bind />標簽生成的，或者<foreach />標簽中的集合的元素）

BoundSql

org.apache.ibatis.mapping.BoundSql：用於數據庫可執行的SQL語句的最終封裝對象，一個普通的實體類，代碼如下：

public class BoundSql {
  /**
   * SQL 語句
   */
  private final String sql;
  /**
   * 占位符 ? 對應的入參信息
   */
  private final List<ParameterMapping> parameterMappings;
  /**
   * 入參對象
   */
  private final Object parameterObject;
  /**
   * 附加參數集合
   */
  private final Map<String, Object> additionalParameters;
  /**
   * 附加參數的 MetaObject 對象，便於操作
   */
  private final MetaObject metaParameters;

  public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.parameterObject = parameterObject;
    this.additionalParameters = new HashMap<>();
    this.metaParameters = configuration.newMetaObject(additionalParameters);
  }

  public String getSql() {
    return sql;
  }

  public List<ParameterMapping> getParameterMappings() {
    return parameterMappings;
  }

  public Object getParameterObject() {
    return parameterObject;
  }

  public boolean hasAdditionalParameter(String name) {
    String paramName = new PropertyTokenizer(name).getName();
    return additionalParameters.containsKey(paramName);
  }

  public void setAdditionalParameter(String name, Object value) {
    metaParameters.setValue(name, value);
  }

  public Object getAdditionalParameter(String name) {
    return metaParameters.getValue(name);
  }
}

DefaultParameterHandler

org.apache.ibatis.scripting.defaults.DefaultParameterHandler：實現了ParameterHandler接口，默認實現類，僅提供這個實現類，用於將入參設置到java.sql.PreparedStatement預編譯對象中

回看到org.apache.ibatis.scripting.xmltags.XMLLanguageDriver語言驅動類中，實現了createParameterHandler方法，返回的參數處理器就是該對象

代碼如下：

public class DefaultParameterHandler implements ParameterHandler {

	private final TypeHandlerRegistry typeHandlerRegistry;

    /**
     * MappedStatement 對象
     */
	private final MappedStatement mappedStatement;
    /**
     * 入參
    */
	private final Object parameterObject;
    /**
     * BoundSql 對象，實際的 SQL 語句
     */
	private final BoundSql boundSql;
    /**
     * 全局配置對象
     */
	private final Configuration configuration;

	public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
		this.mappedStatement = mappedStatement;
		this.configuration = mappedStatement.getConfiguration();
		this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
		this.parameterObject = parameterObject;
		this.boundSql = boundSql;
	}

	@Override
	public Object getParameterObject() {
		return parameterObject;
	}

	@Override
	public void setParameters(PreparedStatement ps) {
		ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
		// 獲取 SQL 的參數信息 ParameterMapping 對象
		List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
		if (parameterMappings != null) {
			// 遍歷所有參數
			for (int i = 0; i < parameterMappings.size(); i++) {
				ParameterMapping parameterMapping = parameterMappings.get(i);
                /*
                 * OUT 表示參數僅作為出參，非 OUT 也就是需要作為入參
                 */
				if (parameterMapping.getMode() != ParameterMode.OUT) {
					Object value;
					// 獲取入參的屬性名
					String propertyName = parameterMapping.getProperty();
					/*
					 * 獲取入參的實際值
					 */
					if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
					  // 在附加參數集合（<bind />標簽生成的）中獲取
						value = boundSql.getAdditionalParameter(propertyName);
					} else if (parameterObject == null) {
					  // 入參為 null 則該屬性也定義為 null
						value = null;
					} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
					  // 有類型處理器，則直接獲取入參對象
						value = parameterObject;
					} else {
					  // 創建入參對應的 MetaObject 對象並獲取該屬性的值
						MetaObject metaObject = configuration.newMetaObject(parameterObject);
						value = metaObject.getValue(propertyName);
					}
					// 獲取定義的參數類型處理器
					TypeHandler typeHandler = parameterMapping.getTypeHandler();
					// 獲取定義的 Jdbc Type
					JdbcType jdbcType = parameterMapping.getJdbcType();
					if (value == null && jdbcType == null) {
						// 如果沒有則設置成 'OTHER'
						jdbcType = configuration.getJdbcTypeForNull();
					}
					try {
						// 通過定義的 TypeHandler 參數類型處理器將 value 設置到對應的占位符
						typeHandler.setParameter(ps, i + 1, value, jdbcType);
					} catch (TypeException | SQLException e) {
						throw new TypeException(
								"Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
					}
				}
			}
		}
	}
}

往PreparedStatement中設置參數的大致邏輯如下：

獲取SQL的參數信息ParameterMapping對象的集合，然后對其遍歷
如果參數的模式不為ParameterMode.OUT（默認為ParameterMode.IN），也就是說需要作為入參，那么開始接下來的賦值
獲取該參數對應的屬性名稱，並通過其獲取到對應的值
獲取到TypeHandler類型處理器（在ParameterMapping構建的時候會創建對應的TypeHandler）
獲取到Jdbc Type
通過TypeHandler類型處理器，根據參數位置和Jdbc Type將屬性值設置到PreparedStatement中

這樣就完成對PreparedStatement的賦值，然后通過它執行SQL語句

總結

在MyBatis初始化的過程中，會將XML映射文件中的<select /> <insert /> <update /> <delete />節點解析成MappedStatement對象，其中會將節點中定義的SQL語句通過XMLLanguageDriver語言驅動類創建一個SqlSource對象，本文就是對該對象進行分析

通過SqlSource這個對象根據入參可以獲取到對應的BoundSql對象，BoundSql對象中包含了數據庫需要執行的SQL語句、ParameterMapping參數信息、入參對象和附加的參數（通過<bind />標簽生成的，或者<foreach />標簽中的集合的元素等等）

好了，對於MyBatis的整個初始化過程我們已經全部分析完了，其中肯定有不對或者迷惑的地方，歡迎指正！！！感謝大家的閱讀！！！😄😄😄

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 MyBatis 源碼分析 - MyBatis初始化（三）之 SQL 初始化（上） mybatis 源碼分析（二）mapper 初始化 MyBatis源碼分析-MyBatis初始化流程 mybatis源碼解讀(一)——初始化環境 MyBatis 源碼分析 - MyBatis初始化（一）之加載 mybatis-config.xml Mybatis源碼詳解系列(二)--Mybatis如何加載配置及初始化 MyBatis 源碼分析 - MyBatis初始化（二）之加載 Mapper 接口與 XML 映射文件 Mybatis的初始化和結合Spring Framework后初始化的源碼探究從底層源碼淺析Mybatis的SqlSessionFactory初始化過程 mybatis源碼解析7---MappedStatement初始化過程