精尽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在解析<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;
}

1. 如果是动态 SQL 语句，使用了 MyBatis 的自定义标签（<if /> <foreach />等）或者使用了 ${} 都是动态 SQL 语句，则会创建DynamicSqlSource对象
2. 否则就是静态 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方法

包含的${}也已经注入了对应的值，所以这里只剩#{}定义的入参了

1. 创建ParameterMappingTokenHandler处理器对象handler
2. 创建GenericTokenParser对象，用于处理#{}中的内容，通过handler将其转换成?占位符，并创建对应的ParameterMapping对象
3. 执行解析，获取最终的 SQL 语句
4. 创建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)方法：

1. 调用buildParameterMapping(content)方法，解析#{}的内容创建ParameterMapping对象

2. 直接返回?占位符

buildParameterMapping(content)方法：

1. 将字符串解析成 key-value 键值对，通过org.apache.ibatis.builder.ParameterExpression进行解析，其中有一个key为"property"，value就是对应的属性名称
2. 获得属性的名字和类型
3. 创建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开始位置小于字符串的长度，那么开始解析

1. 调用skipUntil方法，获取从left开始,或者:第一个位置，也就是分隔符的位置

2. 这里第一次进入的话就会先获取第一个,的位置，那么调用trimmedStr方法截取前面的字符串，也就是属性名称，然后存放一个键值对（key为property，value为属性名称）

3. 调用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方法：

1. 创建一个上下文对象DynamicContext，入参信息为null
2. 调用StaticTextSqlNode的apply方法，将所有的SQL拼接在一起
3. 返回拼接好的SQL语句

构造方法：

1. 创建SqlSourceBuilder构建对象sqlSourceParser
2. 调用sqlSourceParser的parse方法对该SQL语句进行转换，#{}全部替换成?占位符，并创建对应的ParameterMapping对象
3. 第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方法：

1. 创建本次解析的动态 SQL 语句的上下文，设置入参信息
2. 根据上下文应用整个 SqlNode，内部包含的所有SqlNode都会被应用，最终解析后的SQL会保存上下文中
3. 创建 SqlSourceBuilder 构建对象sqlSourceParser
4. 调用sqlSourceParser的parse方法对第2步解析后的SQL语句进行转换，#{}全部替换成?占位符，并创建对应的ParameterMapping对象
5. 通过第4步返回的StaticSqlSource对象创建BoundSql对象
6. 添加附加参数到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中设置参数的大致逻辑如下：

1. 获取SQL的参数信息ParameterMapping对象的集合，然后对其遍历
2. 如果参数的模式不为ParameterMode.OUT（默认为ParameterMode.IN），也就是说需要作为入参，那么开始接下来的赋值
3. 获取该参数对应的属性名称，并通过其获取到对应的值
4. 获取到TypeHandler类型处理器（在ParameterMapping构建的时候会创建对应的TypeHandler）
5. 获取到Jdbc Type
6. 通过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 源码分析》