MyBatis詳細源碼解析（上篇）
前言
我會一步一步帶你剖析MyBatis這個經典的半ORM框架的源碼！
我是使用Spring Boot + MyBatis的方式進行測試，但並未進行整合，還是使用最原始的方式。
項目結構
導入依賴：
-
mybatis：mybatis
-
mysql-connector-java：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"
"//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"
"//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);
}
}
}
```[]()
