前言

废话不多说，直接进入文章。
我们在使用 mybatis 的时候，会在 xml 中编写 sql 语句。
比如这段动态 sql 代码：

<update id="update" parameterType="org.format.dynamicproxy.mybatis.bean.User">
    UPDATE users
    <trim prefix="SET" prefixOverrides=",">
        <if test="name != null and name !=''">
            name = #{name}
        </if>
        <if test="age != null and age !=''">
            , age = #{age}
        </if>
        <if test="birthday != null and birthday !=''">
            , birthday = #{birthday}
        </if>
    </trim>
    where id = ${id}
</update>

mybatis 底层是如何构造这段 sql 的？
这方面的知识网上资料不多，于是就写了这么一篇文章。
下面带着这个疑问，我们一步一步分析。

介绍 MyBatis 中一些关于动态 SQL 的接口和类

SqlNode 接口，简单理解就是 xml 中的每个标签，比如上述 sql 的 update,trim,if 标签：

public interface SqlNode {
  boolean apply(DynamicContext context);
}

SqlSource Sql 源接口，代表从 xml 文件或注解映射的 sql 内容，主要就是用于创建 BoundSql，有实现类 DynamicSqlSource(动态 Sql 源)，StaticSqlSource(静态 Sql 源) 等：

public interface SqlSource {
  BoundSql getBoundSql(Object parameterObject);
}

BoundSql 类，封装 mybatis 最终产生 sql 的类，包括 sql 语句，参数，参数源数据等参数：

XNode，一个 Dom API 中的 Node 接口的扩展类。

BaseBuilder 接口及其实现类(属性，方法省略了，大家有兴趣的自己看), 这些 Builder 的作用就是用于构造 sql:

下面我们简单分析下其中 4 个 Builder：

1 XMLConfigBuilder

解析 mybatis 中 configLocation 属性中的全局 xml 文件，内部会使用 XMLMapperBuilder 解析各个 xml 文件。

2 XMLMapperBuilder

遍历 mybatis 中 mapperLocations 属性中的 xml 文件中每个节点的 Builder，比如 user.xml，内部会使用 XMLStatementBuilder 处理 xml 中的每个节点。

3 XMLStatementBuilder

解析 xml 文件中各个节点，比如 select,insert,update,delete 节点，内部会使用 XMLScriptBuilder 处理节点的 sql 部分，遍历产生的数据会丢到 Configuration 的 mappedStatements 中。

4 XMLScriptBuilder

解析 xml 中各个节点 sql 部分的 Builder。

LanguageDriver 接口及其实现类(属性，方法省略了，大家有兴趣的自己看)，该接口主要的作用就是构造 sql:

简单分析下 XMLLanguageDriver(处理 xml 中的 sql，RawLanguageDriver 处理静态 sql)：

XMLLanguageDriver 内部会使用 XMLScriptBuilder 解析 xml 中的 sql 部分。

ok， 大部分比较重要的类我们都已经介绍了，下面源码分析走起。

源码分析走起

Spring 与 Mybatis 整合的时候需要配置 SqlSessionFactoryBean，该配置会加入数据源和 mybatis xml 配置文件路径等信息：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation" value="classpath:mybatisConfig.xml"/>
	<property name="mapperLocations" value="classpath*:org/format/dao/*.xml"/>
</bean>

我们就分析这一段配置背后的细节：

SqlSessionFactoryBean 实现了 Spring 的 InitializingBean 接口，InitializingBean 接口的 afterPropertiesSet 方法中会调用 buildSqlSessionFactory 方法

buildSqlSessionFactory 方法内部会使用 XMLConfigBuilder 解析属性 configLocation 中配置的路径，还会使用 XMLMapperBuilder 属性解析 mapperLocations 属性中的各个 xml 文件。

部分源码如下：

由于 XMLConfigBuilder 内部也是使用 XMLMapperBuilder，我们就看看 XMLMapperBuilder 的解析细节。

我们关注一下，增删改查节点的解析。

XMLStatementBuilder 的解析：

默认会使用 XMLLanguageDriver 创建 SqlSource（Configuration 构造函数中设置）。

XMLLanguageDriver 创建 SqlSource：

XMLScriptBuilder 解析 sql：

得到 SqlSource 之后，会放到 Configuration 中，有了 SqlSource，就能拿 BoundSql 了，BoundSql 可以得到最终的 sql。

实例分析

我以以下 xml 的解析大概说下 parseDynamicTags 的解析过程：

<update id="update" parameterType="org.format.dynamicproxy.mybatis.bean.User">
    UPDATE users
    <trim prefix="SET" prefixOverrides=",">
        <if test="name != null and name !=''">
            name = #{name}
        </if>
        <if test="age != null and age !=''">
            , age = #{age}
        </if>
        <if test="birthday != null and birthday !=''">
            , birthday = #{birthday}
        </if>
    </trim>
    where id = ${id}
</update>

在看这段解析之前，请先了解 dom 相关的知识，xml dom 知识, dom 博文

parseDynamicTags 方法的返回值是一个 List，也就是一个 Sql 节点集合。SqlNode 本文一开始已经介绍，分析完解析过程之后会说一下各个 SqlNode 类型的作用。

1 首先根据 update 节点 (Node) 得到所有的子节点，分别是 3 个子节点

(1) 文本节点 \n UPDATE users

(2)trim 子节点 ...

(3) 文本节点 \n where id = #{id}

2 遍历各个子节点

(1) 如果节点类型是文本或者 CDATA，构造一个 TextSqlNode 或 StaticTextSqlNode

(2) 如果节点类型是元素，说明该 update 节点是个动态 sql，然后会使用 NodeHandler 处理各个类型的子节点。这里的 NodeHandler 是 XMLScriptBuilder 的一个内部接口，其实现类包括 TrimHandler、WhereHandler、SetHandler、IfHandler、ChooseHandler 等。看类名也就明白了这个 Handler 的作用，比如我们分析的 trim 节点，对应的是 TrimHandler；if 节点，对应的是 IfHandler...

这里子节点 trim 被 TrimHandler 处理，TrimHandler 内部也使用 parseDynamicTags 方法解析节点

3 遇到子节点是元素的话，重复以上步骤

trim 子节点内部有 7 个子节点，分别是文本节点、if 节点、是文本节点、if 节点、是文本节点、if 节点、文本节点。文本节点跟之前一样处理，if 节点使用 IfHandler 处理

遍历步骤如上所示，下面我们看下几个 Handler 的实现细节。

IfHandler 处理方法也是使用 parseDynamicTags 方法，然后加上 if 标签必要的属性。

private class IfHandler implements NodeHandler {
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      List<SqlNode> contents = parseDynamicTags(nodeToHandle);
      MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
      String test = nodeToHandle.getStringAttribute("test");
      IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
      targetContents.add(ifSqlNode);
    }
}

TrimHandler 处理方法也是使用 parseDynamicTags 方法，然后加上 trim 标签必要的属性。

private class TrimHandler implements NodeHandler {
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      List<SqlNode> contents = parseDynamicTags(nodeToHandle);
      MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
      String prefix = nodeToHandle.getStringAttribute("prefix");
      String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
      String suffix = nodeToHandle.getStringAttribute("suffix");
      String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
      TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
      targetContents.add(trim);
    }
}

以上 update 方法最终通过 parseDynamicTags 方法得到的 SqlNode 集合如下：

trim 节点：

由于这个 update 方法是个动态节点，因此构造出了 DynamicSqlSource。

DynamicSqlSource 内部就可以构造 sql 了:

DynamicSqlSource 内部的 SqlNode 属性是一个 MixedSqlNode。

然后我们看看各个 SqlNode 实现类的 apply 方法

下面分析一下两个 SqlNode 实现类的 apply 方法实现：

MixedSqlNode：

public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : contents) {
      sqlNode.apply(context);
    }
    return true;
}

MixedSqlNode 会遍历调用内部各个 sqlNode 的 apply 方法。

StaticTextSqlNode:

public boolean apply(DynamicContext context) {
    context.appendSql(text);
    return true;
}

直接 append sql 文本。

IfSqlNode:

public boolean apply(DynamicContext context) {
    if (evaluator.evaluateBoolean(test, context.getBindings())) {
      contents.apply(context);
      return true;
    }
    return false;
}

这里的 evaluator 是一个 ExpressionEvaluator 类型的实例，内部使用了 OGNL 处理表达式逻辑。

TrimSqlNode:

public boolean apply(DynamicContext context) {
    FilteredDynamicContext filteredDynamicContext = new FilteredDynamicContext(context);
    boolean result = contents.apply(filteredDynamicContext);
    filteredDynamicContext.applyAll();
    return result;
}
public void applyAll() {
sqlBuffer = new StringBuilder(sqlBuffer.toString().trim());
String trimmedUppercaseSql = sqlBuffer.toString().toUpperCase(Locale.ENGLISH);
if (trimmedUppercaseSql.length() > 0) {
applyPrefix(sqlBuffer, trimmedUppercaseSql);
applySuffix(sqlBuffer, trimmedUppercaseSql);
}
delegate.appendSql(sqlBuffer.toString());
}
private void applyPrefix(StringBuilder sql, String trimmedUppercaseSql) {
if (!prefixApplied) {
prefixApplied = true;
if (prefixesToOverride != null) {
for (String toRemove : prefixesToOverride) {
if (trimmedUppercaseSql.startsWith(toRemove)) {
sql.delete(0, toRemove.trim().length());
break;
}
}
}
if (prefix != null) {
sql.insert(0, " ");
sql.insert(0, prefix);
}
}
}

TrimSqlNode 的 apply 方法也是调用属性 contents(一般都是 MixedSqlNode) 的 apply 方法，按照实例也就是 7 个 SqlNode，都是 StaticTextSqlNode 和 IfSqlNode。 最后会使用 FilteredDynamicContext 过滤掉 prefix 和 suffix。

总结

大致讲解了一下 mybatis 对动态 sql 语句的解析过程，其实回过头来看看不算复杂，还算蛮简单的。 之前接触 mybaits 的时候遇到刚才分析的那一段动态 sql 的时候总是很费解。

<update id="update" parameterType="org.format.dynamicproxy.mybatis.bean.User">
    UPDATE users
    <trim prefix="SET" prefixOverrides=",">
        <if test="name != null and name !=''">
            name = #{name}
        </if>
        <if test="age != null and age !=''">
            , age = #{age}
        </if>
        <if test="birthday != null and birthday !=''">
            , birthday = #{birthday}
        </if>
    </trim>
    where id = ${id}
</update>

想搞明白这个 trim 节点的 prefixOverrides 到底是什么意思 (从字面上理解就是前缀覆盖)，而且官方文档上也没这方面知识的说明。我将这段 xml 改成如下：

<update id="update" parameterType="org.format.dynamicproxy.mybatis.bean.User">
    UPDATE users
    <trim prefix="SET" prefixOverrides=",">
        <if test="name != null and name !=''">
            , name = #{name}
        </if>
        <if test="age != null and age !=''">
            , age = #{age}
        </if>
        <if test="birthday != null and birthday !=''">
            , birthday = #{birthday}
        </if>
    </trim>
    where id = ${id}
</update>

(第二段第一个 if 节点多了个逗号) 结果我发现这 2 段 xml 解析的结果是一样的，非常迫切地想知道这到底是为什么，然后这也促使了我去看源码的决心。最终还是看下来了。

文章有点长，而且讲的也不是非常直观，希望对有些人有帮助。