Mybatis核心配置文件加载流程详解
作者：JermeryBesian
本文将介绍MyBatis在配置文件加载的过程中,如何加载核心配置文件、如何解析映射文件中的SQL语句以及每条SQL语句如何与映射接口的方法进行关联,具有一定的参考价值,感兴趣的可以了解一下
本文将介绍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加载配置文件的流程进行一个总结：
到此这篇关于Mybatis核心配置文件加载流程详解的文章就介绍到这了,更多相关Mybatis核心配置文件加载内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！