前言
我会一步一步带你剖析MyBatis这个经典的半ORM框架的源码！
我是使用Spring Boot + MyBatis的方式进行测试，但并未进行整合，还是使用最原始的方式。
项目结构
导入依赖：
-
mybatis：https://mvnrepository.com/artifact/org.mybatis/mybatis
-
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构造方法中创建了两个对象：
- TypeAliasRegistry。
- 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>节点做单文件映射。
我们看下面的三行代码，发现单文件映射有三种方式：
-
第一种使用<mapper>节点的resource属性直接映射XML文件。
-
第二种是使用<mapper>节点url属性映射网络或者磁盘路径下的某个XML文件。
-
第三种是使用<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);
}
}
}
```[]()