Mybatis核心配置文件加载流程详解
本文将介绍MyBatis在配置文件加载的过程中，如何加载核心配置文件、如何解析映射文件中的SQL语句以及每条SQL语句如何与映射接口的方法进行关联。
映射配置文件
在介绍核心配置文件加载流程前，先给出一个简单的MyBatis的配置文件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>
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="localCacheScope" value="STATEMENT"/>
</settings>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/local?allowPublicKeyRetrieval=false"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/UserMapper.xml"/>
<mapper resource="mapper/OrderMapper.xml"/>
</mappers>
</configuration>
上面的XMl配置文件中，包含了一些核心标签，比如
<settings>标签：用于配置 MyBatis 的全局设置，包括设置缓存、懒加载、日志实现、数据库元信息获取方式等。您可以在这里定义各种全局设置，以定制 MyBatis 的行为。<environments>标签：用于配置 MyBatis 的数据库环境，包括数据源信息、事务管理器等。这个标签允许您配置多个环境，每个环境可以包含一个或多个数据源，以及相应的事务管理器。<mappers>标签：用于指定 MyBatis 映射器（Mapper）接口或映射文件的位置。在这个标签中，您可以列出要使用的 Mapper 接口或 XML 映射文件，MyBatis 将会加载这些映射器并将其配置为可用的映射器。
在<mappers>标签中，有下面两种子节点，标签分别为<mapper>和<package>，这两种标签的说明如下所示：
<mapper>：该标签有三种属性，分别是resource、url和class，且在同一个标签中，只能设置其中一个。其中，resource和url属性均是通过告诉MyBatis映射文件所在的位置路径来注册映射文件，前者使用相对路径（相对于classpath，例如上面的mapper/UserMapper.xml），后者使用绝对路径。 class属性是通过告诉MyBatis映射文件对应的映射接口的全限定名来注册映射接口，此时要求映射文件与映射接口同名且同目录。<package>：通过设置映射接口所在包名来注册映射接口，此时要求映射文件与映射接口同名且同目录。
上面列出了一些概念性的点，接下来我们通过源码来分析MyBatis是如何来加载和解析上面的配置文件的，并在源码中找到上面概念的佐证。
加载映射文件的源码分析
在读取配置文件时，我们通常会使用Resources.getResourceAsStream方法，利用字节输入流来读取配置文件。接下来，利用SqlSessionFactoryBuilder的build方法，来读取该输入流，并将文件内容进行解析，加载到MyBatis中全局唯一的Configuration配置类中，从而完成配置文件的加载。代码如下所示：
InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSessionFactoryBuilder是一个建造者，其提供了共计9个重载的build()方法用于构建SqlSessionFactory，这9个build()方法可以分为三类，概括如下：
- 基于配置文件字符流构建SqlSessionFactory；
- 基于配置文件字节流构建SqlSessionFactory；
- 基于Configuration类构建SqlSessionFactory。
下面以基于配置文件字节流构建SqlSessionFactory的过程为例，对整个读配置文件的流程进行说明。上面的示例中调用的build() 方法最终会进入到下面的方法中：
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
try {
// XMLConfigBuiler会解析配置文件并生成Configuration类
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
// 调用入参为Configuration的build()方法构建SqlSessionFactory并返回
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.
}
}
}
可以发现，对配置文件的解析是在XMLConfigBuilder的parse()方法中的。先来看一下上面创建的XMLConfigBuilder实例：
public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
}
private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
super(new Configuration());
ErrorContext.instance().resource("SQL Mapper Configuration");
this.configuration.setVariables(props);
this.parsed = false;
this.environment = environment;
this.parser = parser;
}
可以看到XMLConfigBuilder对XML的解析是依靠XPathParser，而XPathParser是MyBatis提供的基于JAVA XPath的解析器。同时，XMLConfigBuilder通过继承BaseBuilder，在内部维护了一个Configuration，通过XPathParser解析得到的配置属性均会保存在Configuration中。
另外，在上面的new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()方法中，MyBatis会借助于DOMParser 来将配置文件的输入流解析成Document来表示。
public Document parse(InputSource is) throws SAXException, IOException {
if (is == null) {
throw new IllegalArgumentException(
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN,
"jaxp-null-input-source", null));
}
if (fSchemaValidator != null) {
if (fSchemaValidationManager != null) {
fSchemaValidationManager.reset();
fUnparsedEntityHandler.reset();
}
resetSchemaValidator();
}
// 利用DOMParser将配置文件字节输入流解析成Document对象
domParser.parse(is);
Document doc = domParser.getDocument();
domParser.dropDocumentReferences();
return doc;
}
回到上面的parse()方法中：
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
其中，parser.evalNode("/configuration")就是从上面解析好的 Document对象中，利用xPath获取到configuration标签（根节点），然后将<configuration标签下的内容传入parseConfiguration方法中。该方法中其实也就是相同的利用xPath来获取指定标签下的内容：
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
// 获取properties标签下的内容进行处理
propertiesElement(root.evalNode("properties"));
// 获取settings标签下的内容
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
loadCustomLogImpl(settings);
// 获取typeAliases标签下的内容
typeAliasesElement(root.evalNode("typeAliases"));
// 获取plugins标签下的内容
pluginElement(root.evalNode("plugins"));
// 获取objectFactory标签下的内容
objectFactoryElement(root.evalNode("objectFactory"));
// 获取objectWrapperFactory标签下的内容
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
// 获取reflectorFactory标签下的内容
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
// 获取environments标签下的内容
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
typeHandlerElement(root.evalNode("typeHandlers"));
// 获取mappers标签下的内容
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
可以看到，上面的方法会分别获取配置文件中的各种类型的标签内容，然后执行相应的处理逻辑，实际上也是我们通用的一种处理XML文件的解析处理过程。接下来，我们选择mappers标签，来重点看看其中的处理逻辑，也就是mapperElement方法：
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
// 处理package子节点
if ("package".equals(child.getName())) {
String mapperPackage = child.getStringAttribute("name");
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) {
// 处理mapper子节点的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) {
// 处理mapper子节点的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属性
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.");
}
}
}
}
}
上面的处理逻辑很清晰了，XNode parent即是<mappers>标签，首先利用getChildren方法来获取下面的子节点。判断如果是<package>子标签，则获取其name属性值，并调用configuration.addMappers进行处理。如果不是，则进入else分支，来处理<mapper>标签里的属性。 本文初介绍过<mapper>标签支持的属性值，且只能设置其中的一个，这里就找到了代码的佐证。
在上面的代码中可以发现，对于不同的标签和属性，分别有两种处理方式，一种是调用configuration.addMappers方法，另一种是调用mapperParser.parse()，接下来我们分别来看一下这两种方法的处理逻辑。
首先来看一下configuration.addMappers：
public void addMappers(String packageName) {
mapperRegistry.addMappers(packageName);
}
/**
* @since 3.2.2
*/
public void addMappers(String packageName) {
addMappers(packageName, Object.class);
}
/**
* @since 3.2.2
*/
public void addMappers(String packageName, Class<?> superType) {
ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
for (Class<?> mapperClass : mapperSet) {
addMapper(mapperClass);
}
}
层层调用addMappers方法，在上面第三个重载方法中，创建了一个ResolverUtil实例，ResolverUtil用来定位给定类路径中的可用且满足任意条件的类。 因此，resolverUtil.find(new ResolverUtil.IsA(superType), packageName) 实际上就是找到给定类路径packageName下的所有可用类：
public ResolverUtil<T> find(Test test, String packageName) {
// 将packageName中的.转换成/
String path = getPackagePath(packageName);
try {
// 扫描从所提供的包开始到子包的类
List<String> children = VFS.getInstance().list(path);
for (String child : children) {
if (child.endsWith(".class")) {
// 如果URL资源描述符以.class结尾，则判断是否加入到matches集合中
addIfMatching(test, child);
}
}
} catch (IOException ioe) {
log.error("Could not read package: " + packageName, ioe);
}
return this;
}
// 当且仅当提供的测试批准时，将所提供的完全限定类名指定的类添加到已解析类集中。
protected void addIfMatching(Test test, String fqn) {
try {
String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
// 获取类加载器
ClassLoader loader = getClassLoader();
if (log.isDebugEnabled()) {
log.debug("Checking to see if class " + externalName + " matches criteria [" + test + "]");
}
// 利用类加载器加载全限定类名指定的类
Class<?> type = loader.loadClass(externalName);
if (test.matches(type)) {
// 如果test验证条件匹配后，则将该类加入到matches集合中
// 这里的test.matches实际上就是判断type对应的类的父类是不是Object类
matches.add((Class<T>) type);
}
} catch (Throwable t) {
log.warn("Could not examine class '" + fqn + "'" + " due to a " +
t.getClass().getName() + " with message: " + t.getMessage());
}
}
上面我们花费了一定篇幅来细致地分析了addMappers方法中实现的核心逻辑，目前我们可以知道，resolverUtil.getClasses()方法就是获取到<package>标签中name属性指定的包名及其子包下的所有类，然后进行遍历，对每个类执行addMapper方法：
public <T> void addMapper(Class<T> type) {
// 如果该类是一个接口类
if (type.isInterface()) {
// 判断knownMappers中是否已经有当前映射接口
// Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
// knownMappers是一个map存储结构，key为映射接口Class对象，value为MapperProxyFactory
// MapperProxyFactory为映射接口对应的动态代理工厂
if (hasMapper(type)) {
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
boolean loadCompleted = false;
try {
// knownMappers中存储每个映射接口对应的动态代理工厂
knownMappers.put(type, new MapperProxyFactory<>(type));
// It's important that the type is added before the parser is run
// otherwise the binding may automatically be attempted by the
// mapper parser. If the type is already known, it won't try.
// 依靠MapperAnnotationBuilder来完成映射文件和映射接口中的Sql解析
// 先解析映射文件，再解析映射接口
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
parser.parse();
loadCompleted = true;
} finally {
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}
上面代码中最重要的就是我们发现，MyBatis在解析配置文件的过程中，针对给定包名下的每个接口类，都生成了一个相应的MapperProxyFactory实例，并保存在knownMapeprs的HashMap中。 顾名思义，MapperProxyFactory就是映射接口的动态代理工厂，负责为对应的映射接口生成动态代理类。这里动态代理的生成逻辑我们暂且按下不表，先继续看一下上面对映射文件和映射接口中的SQL进行解析的MapeprAnnotationBuilder类，该类中包含了下面一些属性：
private final Configuration configuration;
private final MapperBuilderAssistant assistant;
private final Class<?> type;
可知，每个MapperAnnotationBuilder实例都会对应一个映射接口类，且持有一个全局唯一的Configuration类，目的是为了将parse方法中对映射配置文件的SQL解析丰富进该Configuration中。接下来，我们就继续来探究一下parse()方法中具体执行了什么：
public void parse() {
String resource = type.toString();
// 判断映射接口是否已经被解析过，没解析过才会继续往下执行
if (!configuration.isResourceLoaded(resource)) {
// 解析映射配置文件的内容，并丰富进Configuration中
loadXmlResource();
// 将当前映射接口添加到缓存中，以表示当前映射接口已经被解析过
configuration.addLoadedResource(resource);
assistant.setCurrentNamespace(type.getName());
parseCache();
parseCacheRef();
// 遍历接口类中的所有方法，目的是为了处理接口方法中利用注解方式添加的SQL语句
Method[] methods = type.getMethods();
for (Method method : methods) {
try {
// issue #237
if (!method.isBridge()) {
parseStatement(method);
}
} catch (IncompleteElementException e) {
configuration.addIncompleteMethod(new MethodResolver(this, method));
}
}
}
parsePendingMethods();
}
按照parse()方法的执行流程，会先解析映射配置文件XML中的配置SQL语句，然后再解析接口方法中利用注解方法配置的SQL语句。这里以解析映射文件为例，先来看一下loadXmlResource()方法的实现：
private void loadXmlResource() {
// Spring may not know the real resource name so we check a flag
// to prevent loading again a resource twice
// this flag is set at XMLMapperBuilder#bindMapperForNamespace
if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
// 根据接口类的全限定类名，拼接上.xml来得到相应的映射配置文件
// 这也就是为什么如果是<package>标签，需要映射配置文件和映射接口在同一目录
String xmlResource = type.getName().replace('.', '/') + ".xml";
// #1347
InputStream inputStream = type.getResourceAsStream("/" + xmlResource);
if (inputStream == null) {
// Search XML mapper that is not in the module but in the classpath.
try {
inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
} catch (IOException e2) {
// ignore, resource is not required
}
}
if (inputStream != null) {
XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
// 解析映射配置文件
xmlParser.parse();
}
}
}
在上面的loadXmlResource方法中我们又找到了一处本文初介绍的<package>标签配置时规范的代码佐证，即为什么要求映射文件与映射接口同名且同目录。同样的，对于XML映射配置文件，MyBatis将其转换成字节输入流，并同样利用XMLMapperBuilder类进行解析。这里对XML文件的解析也是我们可以学习的一点，日后在其他地方对XML文件的解析都可以参照这一流程。
另外需要特别注意的一点是，如上图所示，解析核心配置文件和映射配置文件的解析类分别为XMLConfigBuilder和XMLMapperBuilder，均继承自BaseBuilder。而BaseBuilder中持有全局唯一的Configuration，所以两者对配置文件的解析均会丰富进Configuration。
继续进入xmlParser.parse()方法中，来看一下是如何对映射配置文件进行解析的：
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
// 解析映射配置文件的mapper根标签
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
继续看configurationElement的实现：
private void configurationElement(XNode context) {
try {
// 获取<mapper>标签的namespace属性
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
// 解析MyBatis一级/二级缓存相关的标签
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
// 解析<parameterMap>标签，生成ParameterMap并缓存到Configuration
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
// 解析<resultMap>标签，生成ResultMap并缓存到Configuration
resultMapElements(context.evalNodes("/mapper/resultMap"));
// 将<sql>标签对应的SQL片段保存到sqlFragments缓存中
sqlElement(context.evalNodes("/mapper/sql"));
// 解析<selecct> 、<insert>、<update>和<delete>标签
// 生成MappedStatement并缓存到Configuration
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);
}
}
通过上面的方法可以发现，解析XML文件来说，实际上就是xPath获取到每个需要分析的标签，然后将各个子标签解析成相应的类。在MyBatis中，上面对每个子标签的解析结果，最后都会缓存到Configuration中。通常，在映射文件的<mapper>标签下，常用的子标签为<parameterMap>、<resultMap>、<select>、<insert>、<update>、<delete>。下面着重分析一下buildStatementFromContext方法，来看一下MyBatis是如何对上述标签进行解析的。
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) {
// 每一个<select>、<insert>、<update>和<delete>标签均会被创建一个MappedStatement
// 每个MappedStatement会存放在Configuration的mappedStatements缓存中
// mappedStatements是一个map，键为映射接口全限定名+"."+标签id，值为MappedStatement
for (XNode context : list) {
// 上面的每个标签都会创建一个XMLStatementBuilder来进行解析
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
对于每一个<select>、<insert>、<update>和<delete>标签，均会创建一个XMlStatementBuilder来进行解析并生成MappedStatement，同样，看一下XMlStatementBuilder的类图，如下所示：
XMLStatementBuilder中持有<select>，<insert>，<update>和<delete>标签对应的节点XNode，以及帮助创建MappedStatement并丰富进Configuration的MapperBuilderAssistant类。下面看一下XMLStatementBuilder的parseStatementNode() 方法。
public void parseStatementNode() {
// 获取标签id
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
String nodeName = context.getNode().getNodeName();
// 获取标签类型，例如SELECT，INSERT等
SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
// Include Fragments before parsing
// 如果使用了<include>标签，则将<include>标签替换为匹配的<sql>标签中的sql片段
// 匹配规则是在Configuration中根据namespace+"."+refid去匹配<sql>标签
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());
// 获取输入参数类型
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
// 获取LanguageDriver以支持实现动态sql
// 这里获取到的实际上为XMLLanguageDriver
String lang = context.getStringAttribute("lang");
LanguageDriver langDriver = getLanguageDriver(lang);
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
// 获取KeyGenerator
KeyGenerator keyGenerator;
String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
if (configuration.hasKeyGenerator(keyStatementId)) {
keyGenerator = configuration.getKeyGenerator(keyStatementId);
} else {
// 如果缓存中获取不到，则根据useGeneratedKeys的配置决定是否使用KeyGenerator
// 如果要使用，则MyBatis中使用的KeyGenerator为Jdbc3KeyGenerator
keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}
// 通过XMLLanguateDriver创建SqlSource，可以理解为sql语句
// 如果使用到了<if>、<foreach>等标签进行动态sql语句的拼接，则创建出来的SqlSource为DynamicSqlSource
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
// 获取标签上的各种属性
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String resultType = context.getStringAttribute("resultType");
Class<?> resultTypeClass = resolveClass(resultType);
String resultMap = context.getStringAttribute("resultMap");
String resultSetType = context.getStringAttribute("resultSetType");
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
if (resultSetTypeEnum == null) {
resultSetTypeEnum = configuration.getDefaultResultSetType();
}
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
String resultSets = context.getStringAttribute("resultSets");
// 根据上面获取到的参数，创建MappedStatement并添加到Configuration中
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
parseStatementNode() 方法整体流程稍长，总结概括起来该方法做了如下几件事情。
- 将<include>标签替换为其指向的SQL片段；
- 如果未使用动态SQL，则创建RawSqlSource以保存SQL语句，如果使用了动态SQL（例如使用了<if>，<foreach>等标签），则创建DynamicSqlSource以支持SQL语句的动态拼接；
- 获取<select>，<insert>，<update>和<delete>标签上的属性；
- 将获取到的SqlSource以及标签上的属性传入MapperBuilderAssistant的addMappedStatement() 方法，以创建MappedStatement并添加到Configuration中。
MapperBuilderAssistant是最终创建MappedStatement以及将MappedStatement添加到Configuration的处理类，其addMappedStatement() 方法如下所示。
public MappedStatement addMappedStatement(
String id,
SqlSource sqlSource,
StatementType statementType,
SqlCommandType sqlCommandType,
Integer fetchSize,
Integer timeout,
String parameterMap,
Class<?> parameterType,
String resultMap,
Class<?> resultType,
ResultSetType resultSetType,
boolean flushCache,
boolean useCache,
boolean resultOrdered,
KeyGenerator keyGenerator,
String keyProperty,
String keyColumn,
String databaseId,
LanguageDriver lang,
String resultSets) {
if (unresolvedCacheRef) {
throw new IncompleteElementException("Cache-ref not yet resolved");
}
// 拼接出MappedStatement的唯一标识，规则是namespace + ". " + id
id = applyCurrentNamespace(id, false);
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
.resource(resource)
.fetchSize(fetchSize)
.timeout(timeout)
.statementType(statementType)
.keyGenerator(keyGenerator)
.keyProperty(keyProperty)
.keyColumn(keyColumn)
.databaseId(databaseId)
.lang(lang)
.resultOrdered(resultOrdered)
.resultSets(resultSets)
.resultMaps(getStatementResultMaps(resultMap, resultType, id))
.resultSetType(resultSetType)
.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
.useCache(valueOrDefault(useCache, isSelect))
.cache(currentCache);
ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
if (statementParameterMap != null) {
statementBuilder.parameterMap(statementParameterMap);
}
// 创建MappedStatment
MappedStatement statement = statementBuilder.build();
// 将MappedStatement添加到Configuration中
configuration.addMappedStatement(statement);
return statement;
}
至此，我们终于在这里发现了MyBatis是如何解析映射配置文件，生成MappedStatement，并将其加载到Configuration类中。实际上，解析<parameterMap>标签，解析<resultMap>标签的大体流程和上面基本一致，最终都是借助MapperBuilderAssistant生成对应的类（例如ParameterMap，ResultMap）然后再缓存到Configuration中，且每种解析生成的类在对应缓存中的唯一标识为namespace + “.” + 标签id。
最后，回到本小结开头的XMLConfigBuilder中的mapperElement方法，目前我们已经将方法内部的逻辑大致探究清晰，主要的工作就是根据配置文件中的标签下的子标签的不同（ 或 ），以及根据子标签的属性不同，获取到所配置位置的映射配置文件，再使用XMLMapperBuilder类进行统一解析。最后，将解析得到的结果封装成MappedStatement对象，添加到Configuration类。
更为具体的解析细节，大家有兴趣可以阅读源码进行深入的分析，最后，我们利用一个示意图来对上述的MyBatis加载配置文件的流程进行一个总结：
