MyBatis详细源码解析（上篇）

前言

我会一步一步带你剖析MyBatis这个经典的半ORM框架的源码！

我是使用Spring Boot + MyBatis的方式进行测试，但并未进行整合，还是使用最原始的方式。

项目结构

导入依赖：

1. mybatis：https://mvnrepository.com/artifact/org.mybatis/mybatis

2. mysql-connector-java：https://mvnrepository.com/artifact/mysql/mysql-connector-java

Payment表：

Payment实体类：

@Data
public class Payment implements Serializable {
    private Integer id;
    private String serial;
}

PaymentMapper接口：

@Repository
public interface PaymentMapper {
    // 根据Id查询支付信息
    Payment getPaymentById(@Param("id") Integer id);
}

配置文件目录：

Payment.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gzy.mybatistest.mapper.PaymentMapper">
  <select id="getPaymentById" parameterType="integer" resultType="com.gzy.mybatistest.entity.Payment">
    SELECT * FROM payment WHERE id = #{id}
  </select>
</mapper>

database.properties：

# 配置数据库信息
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring_cloud?serverTimezone=Asia/Shanghai
username=username
password=password

mybatis-config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <!-- 导入外部的数据库Properties配置文件 -->
  <properties resource="database.properties"/>

  <!-- 配置MyBatis的环境变量 -->
  <environments default="dev">
    <environment id="dev">
      <!-- 配置事务管理器 -->
      <transactionManager type="JDBC"></transactionManager>
      <!-- 配置数据源 -->
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>

  <!-- 配置SQL映射文件 -->
  <mappers>
    <mapper resource="Payment.xml"/>
  </mappers>
</configuration>

测试类：

@SpringBootTest
class MybatisTestApplicationTests {
    @Test
    void contextLoads() {
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            Payment payment = sqlSession.selectOne("com.gzy.mybatistest.mapper.PaymentMapper.getPaymentById", 1);
            System.out.println(payment);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

相关组件

Configuration：MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中。

SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互时的会话，完成必要数据库增删改查功能。

Executor：MyBatis执行器，是MyBatis调度的核心，负责SQL语句的生成和查询缓存的维护。

StatementHandler：封装了JDBC Statement操作，负责对JDBC Statement的操作，如设置参数等。

ParameterHandler：负责对用户传递的参数转换成JDBC Statement所对应的数据类型。

ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合。

TypeHandler：负责Java数据类型和Jdbc数据类型（也可以说是数据表列类型）之间的映射和转换。

MappedStatement：MappedStatement维护一条<select | update | delete | insert>节点的封装。

SqlSource：负责根据用户传递的ParameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中并返回。

BoundSql：表示动态生成的SQL语句以及相应的参数信息。

执行步骤

第一步

这一步的主要目的就是将MyBatis配置文件加载进内存中。

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

MyBatis的配置文件主要有两个：database.properties和mybatis-config.xml。database.properties用于配置数据库的连接信息，而mybatis-config.xml则是MyBatis的主配置文件，mybatis-config.xml中引入了database.properties的数据库连接信息。

这里MyBatis为我们封装了一个资源读取的工具类Resources，getResourceAsStream方法默认会使用系统类加载器（SystemClassLoader）从resources路径下加载指定文件并且返回一个输入流。

// Resources类，从上至下依次调用
public static InputStream getResourceAsStream(String resource) throws IOException {
    return getResourceAsStream(null, resource);
}

// getResourceAsStream重载方法
public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    // MyBatis在ClassLoader类基础上封装了一层ClassLoaderWrapper包装类
    // 我们可以指定所使用类加载，默认为null
    InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    if (in == null) {
        throw new IOException("Could not find resource " + resource);
    }
    return in;
}

// ClassLoaderWrapper类
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
}

ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
        classLoader, // null
        defaultClassLoader, // null
        Thread.currentThread().getContextClassLoader(), // SystemClassLoader
        getClass().getClassLoader(), // SystemClassLoader
        systemClassLoader}; // SystemClassLoader
}

// getResourceAsStream重载方法
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    for (ClassLoader cl : classLoader) {
        if (null != cl) {
            InputStream returnValue = cl.getResourceAsStream(resource);
            if (null == returnValue) {
                returnValue = cl.getResourceAsStream("/" + resource);
            }
            if (null != returnValue) {
                return returnValue;
            }
        }
    }
    return null;
}

第二步

这一步的主要目的就是解析MyBatis的XML主配置文件，然后将配置信息存入Configuration类中，最后通过Configuration类创建一个SqlSessionFactory接口的实现类DefaultSqlSessionFactory。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

MyBatis使用了建造者模式来创建一个SqlSessionFactory，在SqlSessionFactoryBuilder类中只有build方法（还包括多个重载方法），该方法会创建并返回一个SqlSessionFactory对象。

build方法里面又会看到一个XMLConfigBuilder类，看名字就能知道它是通过XML主配置文件来构建Configuration类。

最终build方法会返回一个SqlSessionFactory接口的实现类DefaultSqlSessionFactory，该类中保存了之前解析出来的Configuration对象。

// SqlSessionFactoryBuilder类中的build方法
public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
}

// SqlSessionFactoryBuilder类中的build重载方法
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        // 解析XML主配置文件
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 返回DefaultSqlSessionFactory对象
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        // 清空ThreadLocal中存储的ErrorContext
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

// 通过解析后的Configuration对象创建DefaultSqlSessionFactory对象
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

public class DefaultSqlSessionFactory implements SqlSessionFactory {
	// 保存了之前解析出来的Configuration对象
    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
    
   	// 省略其他内容...
}

---

首先要做的是解析XML主配置文件前的准备工作！

现在我们进入XMLConfigBuilder类的构造方法，多个重载构造方法层层调用，最终调用了父类BaseBuilder的构造方法。

ErrorContext类是用来记录本次执行过程中相关上下文信息，待发生Error时候其他组件就可以从本类实例中获取到相关的上下文信息，这对于排错是非常有帮助的。

// 继承了抽象类BaseBuilder
public class XMLConfigBuilder extends BaseBuilder {
    private boolean parsed;
    private final XPathParser parser;
    private String environment;
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
    
    public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        // 创建了一个XPahParser对象
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }

    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        // 调用父类的构造方法，同时初始化了一个Configuration对象
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        // 表示当前还并未解析完成
        this.parsed = false;
        // 指定MyBatis所使用环境
        this.environment = environment;
        // 指定MyBatis所使用的XML解析器
        this.parser = parser;
    }
    
    // 省略其他内容...
}

在BaseBuilder构造方法中创建了两个对象：

1. TypeAliasRegistry。
2. TypeHandlerRegistry。

public abstract class BaseBuilder {
    protected final Configuration configuration;
    // 类型别名注册中心
    protected final TypeAliasRegistry typeAliasRegistry;
    // 类型处理注册中心
    protected final TypeHandlerRegistry typeHandlerRegistry;

    public BaseBuilder(Configuration configuration) {
        this.configuration = configuration;
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
    }
    
    // 省略其他内容...
}

TypeAliasRegistry：看类名很容易知道它用于注册一些默认的类型别名。这些别名全都存储在一个名为typeAliases的Map集合中，全部都为小写，包括基本数据类型、基本数据类型的包装类、数组类、集合类等。

public class TypeAliasRegistry {
	// 存储类型别名
    private final Map<String, Class<?>> typeAliases = new HashMap<>();

    //
    public TypeAliasRegistry() {
        registerAlias("string", String.class);

        registerAlias("byte", Byte.class);
        registerAlias("long", Long.class);
        registerAlias("short", Short.class);
        registerAlias("int", Integer.class);
        registerAlias("integer", Integer.class);
        registerAlias("double", Double.class);
        registerAlias("float", Float.class);
        registerAlias("boolean", Boolean.class);
        
        // 省略其他内容...
    }
    
    // 别名的注册方法，MyBatis默认注册和我们自己注册都是使用该方法
    public void registerAlias(String alias, Class<?> value) {
        if (alias == null) {
            throw new TypeException("The parameter alias cannot be null");
        }
        // 设置别名为小写字符串
        String key = alias.toLowerCase(Locale.ENGLISH);
        // 如果别名已存在就抛出异常
        if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
            throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
        }
        // 将别名存入集合
        typeAliases.put(key, value);
    }
}

因此我们在XML映射文件中可以直接使用这些默认别名：

TypeHandlerRegistry：看类名很容易知道它用于数据库类型与Java类型之间的转换（双向转换），以及与数据库之间数据的发送和获取。例如在获取结果时将数据库中的VARCHAR类型转换为Java的String类型、在发送SQL时将Java的Double或double类型转换为数据库中的Double类型等。

类型转换的原理也很简单，就是使用原生JDBC ResultSet结果集中不同数据类型所对应的获取方法和设置方法，例如getSring(String columnLabel)、setString(int parameterIndex, String x)、getByte(String columnLabel)等。

public class StringTypeHandler extends BaseTypeHandler<String> {
    // 在向数据发送SQL时由数据库驱动将Java类型转为对应的数据库类型
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
        throws SQLException {
        ps.setString(i, parameter);
    }

    // 在获取结果时将数据库类型转换为对应的Java类型
    @Override
    public String getNullableResult(ResultSet rs, String columnName)
        throws SQLException {
        return rs.getString(columnName);
    }
    
    // 省略其他内容...
}

---

Configuration类非常简单，就是用来存储MyBatis所有配置信息的类，例如所使用的数据库环境、是否启动驼峰映射、是否启动主键生成策略、是否启动一级缓存等。

// 用于存储MyBatis的配置信息
public class Configuration {
  protected Environment environment;
  protected boolean safeRowBoundsEnabled;
  protected boolean safeResultHandlerEnabled = true;
  protected boolean mapUnderscoreToCamelCase;
  protected boolean aggressiveLazyLoading;
  protected boolean multipleResultSetsEnabled = true;
  protected boolean useGeneratedKeys;
  protected boolean useColumnLabel = true;
  protected boolean cacheEnabled = true; //默认开启一级缓存
  protected boolean callSettersOnNulls;
    
    // 省略其他内容...
}

XMLConfigBuilder构造方法中创建了一个XML解析器，就是XPathParser，它的作用是通过XPath语言来解析XML主配置文件。

XPath：是一门在XML文档中查找信息的语言。XPath可用来在XML文档中对元素和属性进行遍历，XPath是W3C XSLT标准的主要元素，并且XQuery和XPointer都构建于XPath表达之上。

可以看见在commonConstructor方法中通过XPathFactory类创建了一个XPath对象。

public class XPathParser {
    private final Document document;
    private boolean validation;
    private EntityResolver entityResolver;
    private Properties variables;
    private XPath xpath;
    
    // 构造方法
    public XPathParser(InputStream inputStream,
                       boolean validation, Properties variables, EntityResolver entityResolver) {
        commonConstructor(validation, variables, entityResolver);
        // 根据XML主配置文件输入流创建Document对象
        this.document = createDocument(new InputSource(inputStream));
    }

    private void commonConstructor(boolean validation,
                                   Properties variables, EntityResolver entityResolver) {
        this.validation = validation;
        this.entityResolver = entityResolver;
        this.variables = variables;
        XPathFactory factory = XPathFactory.newInstance();
        this.xpath = factory.newXPath();
    }
    
    // 省略其他内容...
}

InputSource：表示XML实体的单个输入源。

Document：Document接口表示整个HTML或XML文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问。

EntityResolver：这个接口主要用于处理本地的XML约束文件（DTD或Schema），MyBatis中使用的是XMLMapperEntityResolver实现类。

XMLMapperEntityResolver类中指明了MyBatis本地的的DTD约束文件路径，并且提供了加载约束文件的方法实现。

public class XMLMapperEntityResolver implements EntityResolver {
    private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";
    private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";
    private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";

    // MyBatis本地的DTD文件路径
    private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";

    // 省略其他内容...
}

---

准备工作完成后就开始真正的解析工作！

先说明一下，我们可以看出主配置文件的最外层节点是<configuration>标签，mybatis的初始化就是把这个标签以及他的所有子标签进行解析，把解析好的数据封装在Configuration这个类中。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 真正地解析XML主配置文件
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

我们进入到XPathBuilder类parse方法中，可以看到它会先进行一个判断，判断MyBatis的XML主配置文件是否已经被解析过，这个parsed属性默认为false。

parseConfiguration方法开始解析XML主配置文件。该方法传入的是一个XNode参数，这个XNode类其实是MyBatis对官方提供的Node类的一层封装。

XNode参数的由来：XPathParser对XPath路径表达式“/configuration”对之前保存的Document对象（代表整个XML主配置文件）进行解析，解析出一个代表着<Configuration>节点的Node，然后将Node封装成XNode。

public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 构建了一个XNode对象
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
    try {
        // issue #117 read properties first
        // 这里依次解析XML主配置文件的各个标签
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        loadCustomLogImpl(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

我们可以看出这个方法是对<configuration>的所有子标签轮流解析。比如常在配置文件中出现的settings属性配置，在settings会配置缓存，日志之类的，还有typeAliases是配置别名，environments是配置数据库链接和事务。这些子节点会被一个个解析并且把解析后的数据封装在Configuration这个类中，可以看第二步方法的返回值就是Configuration对象。

在这里我们重点分析的解析mappers这个子标签，这个标签里面还会有一个个的mapper标签去映射mapper所对应的mapper.xml，可以回头看看主配置文件。

这个方法一开始是一个循环，因为一个<mappers>节点下面可能会有很多<mapper>节点。在应用中肯定不止一个mapper.xml。所以他会去遍历每一个<mapper>节点去解析该节点所映射的XML文件。循环下面是一个判断，它先判断<mappers>下面的子节点是不是package节点，因为在实际开发中有很多的XML文件，有时我们会干脆用一个<package>节点去映射一个包下面的所有的XML文件，这是多文件映射。如果不是<package>节点那肯定就是<mapper>节点做单文件映射。

我们看下面的三行代码，发现单文件映射有三种方式：

1. 第一种使用<mapper>节点的resource属性直接映射XML文件。

2. 第二种是使用<mapper>节点url属性映射网络或者磁盘路径下的某个XML文件。

3. 第三种是使用<mapper>节点的class属性直接映射某个mapper接口。

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            // 判断是否为多文件映射
            if ("package".equals(child.getName())) {
                String mapperPackage = child.getStringAttribute("name");
                // 解析出要映射的包路径并添加至Configuration对象中
                configuration.addMappers(mapperPackage);
            } else {
                // 单文件映射
                // 先解析出三种映射方式的路径
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                
                if (resource != null && url == null && mapperClass == null) { // resource的方式
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == null) { // url的方式
                    ErrorContext.instance().resource(url);
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url == null && mapperClass != null) { // mapper接口的方式
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    configuration.addMapper(mapperInterface);
                } else {
                    throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                }
            }
        }
    }
}

---

实际上映射XML的方式看源码可以得出有三种方式，我们先看resource方式。

第一行代码的意思是实例化一个错误上下文对象，我们回忆一下我们使用MyBatis的过程中如果出现错误会不会提示这个错误在哪个XML中，还提示这个错误在XML中的哪个SQL中。这个对象的作用就是把错误信息封装起来，如果出现错误就会调用这个对象的toString方法。

然后就跟一开始解析XML主配置文件十分相似，使用流的形式读取类路径下的Mapper映射文件，再XMLMapperBuilder类解析。而且XMLMapperBuilder类的构造和XMLConfigBuilder十分相似，只是多了一个用于存储SQL片段XNode的Map集合。

if (resource != null && url == null && mapperClass == null) { // resource的方式
    ErrorContext.instance().resource(resource);
    InputStream inputStream = Resources.getResourceAsStream(resource);
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
    mapperParser.parse();
}

public class XMLMapperBuilder extends BaseBuilder {
    private final XPathParser parser;
    private final MapperBuilderAssistant builderAssistant;
    private final Map<String, XNode> sqlFragments;
    private final String resource;
    
    // 省略其他内容...
}

我们再进入XMLMapperBuilder类的parse方法，一开始就判断这个XML是否被解析过了。因为Configuration对象会维护一个String类型的Set集合loadedResources，这个集合中存放了所有已经被解析过的XML的名字。

如果还未解析过，就会获取一个代表<mapper>节点的XNode对象，然后对<mapper>节点下的所有子节点轮流解析，比如常用的有<resultMap>节点、<sql>节点等。

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
        
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
}

// 依次对mapper节点下的所有子节点进行解析
private void configurationElement(XNode context) {
    try {
        String namespace = context.getStringAttribute("namespace");
        if (namespace == null || namespace.isEmpty()) {
            throw new BuilderException("Mapper's namespace cannot be empty");
        }
        builderAssistant.setCurrentNamespace(namespace);
        cacheRefElement(context.evalNode("cache-ref"));
        cacheElement(context.evalNode("cache"));
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        sqlElement(context.evalNodes("/mapper/sql"));
        // 根据select、insert、update和delete节点构建statement
        buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
}

在末尾我们可以看到有一个buildStatementFromContext方法，它解析了<select>、<insert>、<update>、<delete>四个节点，构建了一个存有所有关联了SQL语句节点的XNode集合。在buildStatementFromContext方法中，它会先判断是否指定了所使用的数据库。然后就是遍历解析List集合，这个List集合里装的是XML中的所有SQL节点，比如“select insert update delete” ，每一个SQL是一个节点。

XMLStatementBuilder类是会话解析器，用于解析每个SQL节点。

private void buildStatementFromContext(List<XNode> list) {
    if (configuration.getDatabaseId() != null) {
        buildStatementFromContext(list, configuration.getDatabaseId());
    }
    buildStatementFromContext(list, null);
}


private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    // 遍历存有SQL节点的集合
    for (XNode context : list) {
        final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
        try {
            // 对SQL节点进行解析
            statementParser.parseStatementNode();
        } catch (IncompleteElementException e) {
            configuration.addIncompleteStatement(statementParser);
        }
    }
}
```[]()