Mybatis核心配置文件加载流程详解

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加载配置文件的流程进行一个总结：