本专辑将介绍mybatis的原理和源码分析。

1、概述

在不使用spring的情况下，我们从官网上可以看到mybatis的使用方法：

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
  Blog blog = session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
} finally {
  session.close();
}

我们可以看到，mybatis启动，首先要加载自己的配置文件，通过配置文件创建SqlSessionFactory，然后再使用SqlSessionFactory对象创建SqlSession对象，通过SqlSession对象来操作数据库。本篇先介绍mybatis加载配置文件的过程。

2、SqlSessionFactoryBuilder

首先我们看一下上面例子中SqlSessionFactoryBuilder的build()方法，我们找到这个方法的最终实现：

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      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.
      }
    }
  }

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

我们可以看到默认SqlSessionFactoryBuilder创建SqlSessionFactory，是直接实例化了一个DefaultSqlSessionFactory对象，在创建DefaultSqlSessionFactory对象的时候需要一个Configuration对象作为构造方法的参数，我们也可以看到Configuration对象是由XMLConfigBuilder读取mybatis-config.xml这个配置文件的信息创建的，我们可以看一下具体的创建过程，我们看一下XMLConfigBuilder的parse()方法：

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

  private void parseConfiguration(XNode root) {
    try {
      // 第一步，加载properties节点，把配置文件中定义配置变量解析出来
      propertiesElement(root.evalNode("properties"));
      // 第二步，加载setting节点，
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      // 第三步，加载类的别名
      typeAliasesElement(root.evalNode("typeAliases"));
      // 第四步，加载插件
      pluginElement(root.evalNode("plugins"));
     // 第五步，加载objectFactory节点
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      // 第八步，将前面settings节点解析出来的配置设置到Configuration中
      settingsElement(settings);
      // 第九步，加载environments节点，
      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);
    }
  }

我们可以看到，mybatis加载配置文件的时候，以configuration节点作为根节点开始解析，首先，加载properties节点，将properties下定义的变量加载到Configuration的variables属性，具体实现比较简单，这里不看源码，有兴趣的朋友可以自己看一下。
第二步，解析settings节点，把配置解析成Properties对象，在mybatis运行的过程中，可以通过修改这些属性来改变mybatis 的行为，具体有哪些配置可以参考Mybatis的文档。这里对vfsImpl参数有个特殊处理，可以指定VFS的实现。
第三步，加载类的别名信息，注册到Configuration的typeAliasRegistry对象中，这个typeAliasRegistry对象中也包含了许多默认的类的别名，如：registerAlias("string", String.class)。注册有两种方式，一种是在<typeAliases></typeAliases>中添加<typeAlias alias="" type=""/>节点，另一种是通过添加<package name="domain.blog"/>直接指定一个包，扫描包中的@Alias("")注解来寻找别名。这些都可以从源码中体现，具体实现源码不再贴出。
第四步，加载mybatis的插件（Interceptor），这里把定义的插件信息读出来，通过反射创建实例，然后注册到Configuration的interceptorChain中。
第五步，加载自定义的ObjectFactory，ObjectFactory是mybatis查询出结果后，创建查询结果使用的对象工厂，默认是直接使用目标类的构造方法进行创建（具体实现可以看一下DefaultObjectFactory这个类），这里用户可以自定义实现。这里把用户自定义的ObjectFactory实现类注册到Configuration的objectFactory属性。
第六步和第七步，分别是加载objectWrapperFactory和reflectorFactory节点，具体过程和加载ObjectFactory节点类似，而且这两个节点在官方文档中没有提及，所以我们大可不必看这两个过程。
第八步，将前面settings节点解析出来的配置设置到Configuration中。
第九步，加载environments节点，environments节点下配置了不同环境下的不同的environment节点，environment节点主要配置了transactionManager和dataSource信息。我们可以看一下具体实现：

  private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
      if (environment == null) {
        environment = context.getStringAttribute("default");
      }
      for (XNode child : context.getChildren()) {
        String id = child.getStringAttribute("id");
        if (isSpecifiedEnvironment(id)) {
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
          DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
          DataSource dataSource = dsFactory.getDataSource();
          Environment.Builder environmentBuilder = new Environment.Builder(id)
              .transactionFactory(txFactory)
              .dataSource(dataSource);
          configuration.setEnvironment(environmentBuilder.build());
        }
      }
    }
  }

我们可以看到，在加载environment的时候，只会去读取default属性指定的environment节点。environment节点下必须要有transactionManager和dataSource节点，不然读取的时候会抛出异常。读取完这些信息之后，会创建Environment对象，并将该对象设置到Configuration的environment属性。
第十步，加载databaseIdProvider节点，databaseIdProvider的具体作用可以看一下mybatis官方文档，我们可以看一下具体实现：

  private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
      String type = context.getStringAttribute("type");
      // awful patch to keep backward compatibility
      if ("VENDOR".equals(type)) {
          type = "DB_VENDOR";
      }
      Properties properties = context.getChildrenAsProperties();
      databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
      databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
      String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
      configuration.setDatabaseId(databaseId);
    }
  }

如果定义了databaseIdProvider，mybatis会根据上面environment定义的datasource来选择会用到的databaseId，并设置到configuration的databaseId属性，以供后面加载statements使用。

第十一步，加载typeHandlers，typeHandlers的功能可以看一下mybatis的官方文档。其作用为：在预处理语句（PreparedStatement）中设置一个参数时，或者从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。解析的最终结果会被注册到Configuration的typeHandlerRegistry中，mybatis定义了很多类型的默认实现，有兴趣的可以看一下源码。typeHandler也可以通过注解的方式定义，这里就不再多说了。
最后一步是加载mappers节点，我们先来看一下解析mappers节点的源码：

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.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) {
            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) {
            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) {
            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.");
          }
        }
      }
    }
  }

首先我们可以看到，在解析mappers子节点的时候，解析方法会被分成两大类，一种是从xml文件中解析（url、source），一种是从Class解析（class、package）。从Class解析比较简单，仅仅是将Class注册到Configuration的mapperRegistry属性中。而解析xml比较复杂，我们来看一下具体过程，其中url和resource通过xml方式定义mapper（也就是我们平时使用的XXXMapper.xml文件），解析xml定义的mapper是交给XMLMapperBuilder来完成的，我们看一下XMLMapperBuilder的parse()方法：

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      // 加载mapper节点下的所有元素
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

第一步，加载mapper节点下的所有元素，我们看一下configurationElement（）方法的具体实现：

  private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        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"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

首先获取mapper的namespace属性，然后将namespace暂存到builderAssistant中，因为在接下来的过程中会频繁用到namespace属性。
接下来解析cache-ref和cache属性，这里很简单，就是单纯的解析节点的属性而已，所以不再赘述，如果不知道cache-ref和cache节点定义的作用的读者，建议去官方文档了解一下这两个标签的作用。
然后是加载parameterMap节点，官方文档已经将这个配置标记为废弃，所以我们可以不用关注这个，我们看一下接下来的解析resultMap的过程。

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
    String id = resultMapNode.getStringAttribute("id",
        resultMapNode.getValueBasedIdentifier());
    String type = resultMapNode.getStringAttribute("type",
        resultMapNode.getStringAttribute("ofType",
            resultMapNode.getStringAttribute("resultType",
                resultMapNode.getStringAttribute("javaType"))));
    String extend = resultMapNode.getStringAttribute("extends");
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    Class<?> typeClass = resolveClass(type);
    Discriminator discriminator = null;
    List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
    resultMappings.addAll(additionalResultMappings);
    List<XNode> resultChildren = resultMapNode.getChildren();
    // 加载子节点
    for (XNode resultChild : resultChildren) {
      if ("constructor".equals(resultChild.getName())) {
        processConstructorElement(resultChild, typeClass, resultMappings);
      } else if ("discriminator".equals(resultChild.getName())) {
        discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
      } else {
        List<ResultFlag> flags = new ArrayList<ResultFlag>();
        if ("id".equals(resultChild.getName())) {
          flags.add(ResultFlag.ID);
        }
        resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
      }
    }
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
      return resultMapResolver.resolve();
    } catch (IncompleteElementException  e) {
      configuration.addIncompleteResultMap(resultMapResolver);
      throw e;
    }
  }

我们可以看到，解析resultMap节点时，首先会解析出id属性，然后再解析出type属性（“ofType”、“resultType”、“javaType”），然后是解析extend属性、autoMapping属性。
接下来就是解析resultMap下的子节点，加载子节点的时候对constructor和discriminator会做特殊处理。constructor和其他的节点一样，都会被解析成一个ResultMapping对象，并加到一个list中。我们可以看一下ResultMapping又那些参数：

  private Configuration configuration;
  private String property;
  private String column;
  private Class<?> javaType;
  private JdbcType jdbcType;
  private TypeHandler<?> typeHandler;
  private String nestedResultMapId;
  private String nestedQueryId;
  private Set<String> notNullColumns;
  private String columnPrefix;
  private List<ResultFlag> flags;
  // 一个<result>节点的column属性中包含多个column的话会被加载成composites
  private List<ResultMapping> composites;
  private String resultSet;
  private String foreignColumn;
  private boolean lazy;

加载逻辑比较简单，这里我们不在赘述，有兴趣的同学可以看一下具体实现。
我们再看一下加载discriminator节点为Discriminator对象的逻辑：

private Discriminator processDiscriminatorElement(XNode context, Class<?> resultType, List<ResultMapping> resultMappings) throws Exception {
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String typeHandler = context.getStringAttribute("typeHandler");
    Class<?> javaTypeClass = resolveClass(javaType);
    @SuppressWarnings("unchecked")
    Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    Map<String, String> discriminatorMap = new HashMap<String, String>();
    for (XNode caseChild : context.getChildren()) {
      String value = caseChild.getStringAttribute("value");
      String resultMap = caseChild.getStringAttribute("resultMap", processNestedResultMappings(caseChild, resultMappings));
      discriminatorMap.put(value, resultMap);
    }
    return builderAssistant.buildDiscriminator(resultType, column, javaTypeClass, jdbcTypeEnum, typeHandlerClass, discriminatorMap);
  }

这里也很简单，分别读取column、javaType、jdbcType、typeHandler属性，然后读取子节点case节点，把不同的value对应的resultMap解析成一个map，之后创建成一个Discriminator对象返回。
最后，系统会将resultMap节点解析出来的各种属性封装成一个ResultMap注册到configuration中。到此，resultMap节点的解析我们就看完了。
我们接下里回到configurationElement()方法中来，在解析完resultMap节点后，接下里会解析sql节点，这里就是生成一个Map，key是sql的id，value是一个XNode节点的对象，解析过程比较简单，我们就不单独看了。
最后就是解析select、insert、update、delete这些节点了，我们可以看一下buildStatementFromContext()方法的实现，我们一层一层最终，最后可以发现，这些节点是交给XMLStatementBuilder的parseStatementNode()方法来解析的，我们先把源码贴出：

public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    // 此处省略部分代码

    LanguageDriver langDriver = getLanguageDriver(lang);

    Class<?> resultTypeClass = resolveClass(resultType);
    String resultSetType = context.getStringAttribute("resultSetType");
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);

    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));

    // 此处省略部分代码

    // 解析节点的子节点
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());

    // 解析SelectKey节点
    processSelectKeyNodes(id, parameterTypeClass, langDriver);
    
    // 将节点内容解析成SqlSource
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
   
    // 此处省略部分代码

    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }

    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

解析这些节点属性的方法都很简单，大家可以看一下源码具体实现，上面的源码省略了这些过程。而解析这些标签子节点的内容这块比较复杂，我们一起来看一下。我们很容易发现，解析节点内容是通过XMLIncludeTransformer的applyIncludes()方法实现的，我们贴出源码来分析：

  public void applyIncludes(Node source) {
    Properties variablesContext = new Properties();
    Properties configurationVariables = configuration.getVariables();
    if (configurationVariables != null) {
      variablesContext.putAll(configurationVariables);
    }
    applyIncludes(source, variablesContext, false);
  }

private void applyIncludes(Node source, final Properties variablesContext, boolean included) {
    if (source.getNodeName().equals("include")) {
      Node toInclude = findSqlFragment(getStringAttribute(source, "refid"), variablesContext);
      Properties toIncludeContext = getVariablesContext(source, variablesContext);
      applyIncludes(toInclude, toIncludeContext, true);
      if (toInclude.getOwnerDocument() != source.getOwnerDocument()) {
        toInclude = source.getOwnerDocument().importNode(toInclude, true);
      }
      source.getParentNode().replaceChild(toInclude, source);
      while (toInclude.hasChildNodes()) {
        toInclude.getParentNode().insertBefore(toInclude.getFirstChild(), toInclude);
      }
      toInclude.getParentNode().removeChild(toInclude);
    } else if (source.getNodeType() == Node.ELEMENT_NODE) {
      NodeList children = source.getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        applyIncludes(children.item(i), variablesContext, included);
      }
    } else if (included && source.getNodeType() == Node.TEXT_NODE
        && !variablesContext.isEmpty()) {
      // replace variables ins all text nodes
      source.setNodeValue(PropertyParser.parse(source.getNodeValue(), variablesContext));
    }
  }

我们可以看到，这是一个递归方法，当加载的节点是include节点，或者节点属性是ELEMENT_NODE的时候，会递归执行，直到节点属性是TEXT_NODE节点。这里我们需要了解一下java解析xml的一些知识，我们举个例子：
有一个xml串：

<a>
  head
  <b></b>
  tail
<a/>

在解析a标签的子Node的时候，会解析出三个子Node，也就是说 head和tail都会被解析成一个Node，其类型为TEXT_NODE，而<b>节点会被解析成ELEMENT_NODE节点。
好了，我们再回到mybatis的解析过程中来。我们先看一下TEXT_NODE解析的过程，这个过程只有在included这个参数传入true的时候才会被触发。我们先来看看这个过程做了什么，这个过程是根据我们之前configuration节点下的properties节点解析出的变量，来替换源text文本中的变量(变量以$()这种方式表示)，替换过程比较复杂，我们也没必要细看，这里就不多说，我们知道只要知道在解析TEXT_NODE节点的时候会做一个变量替换的过程即可。
而解析ELEMENT_NODE的过程很简单，就是递归调用而已，我们也不多说。
最后我们看一下解析include节点，这一步其实也比较简单，就是把当前的include节点替换成include的目标节点。

我们再回到parseStatementNode()方法，在解析完子节点后，mybatis会处理SelectKey节点，具体方法是：processSelectKeyNodes()，处理过程可以概述为：将SelectKey节点解析成一个MappedStatement对象，然后再将MappedStatement对象封装成SelectKeyGenerator对象，然后根据String id = parentId + SelectKeyGenerator.SELECT_KEY_SUFFIX;这个规则生成一个id作为SelectKeyGenerator的id，注册到configuration对象的keyGenerators属性中，最后再把这个SelectKey节点移除，这里我们不贴出源码了，有兴趣的同学可以自己看一下。

接下来我们看到mybatis通过这种方式将节点内容解析成对象：

SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

LanguageDriver有两个实现类：RawLanguageDriver和XMLLanguageDriver。RawLanguageDriver的注释中写到不推荐使用RawLanguageDriver，除非确定要解析的sql是非动态sql，这里我们只看XMLLanguageDriver的实现就行了。我们一步一步追踪，会发现，创建SqlSource 的过程是交给XMLScriptBuilder类的parseScriptNode()方法实现的，我们来看一下：

  public SqlSource parseScriptNode() {
    List<SqlNode> contents = parseDynamicTags(context);
    MixedSqlNode rootSqlNode = new MixedSqlNode(contents);
    SqlSource sqlSource = null;
    if (isDynamic) {
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
  }

  List<SqlNode> parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<SqlNode>();
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlers(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    return contents;
  }

我们可以看到，mybatis会将标签的子节点解析成一个SqlNode的List，如果子节点是TEXT_NODE和CDATA_SECTION_NODE，则直接封装成一个TextSqlNode，如果是ELEMENT_NODE节点，说明是动态sql节点，这里使用NodeHandler来生成SqlNode对象。我们可以先来看一下SqlNode有多少子类：

SqlNode子类

这些子类正好对应我们使用mybatis动态sql的时候用的节点标签。SqlNode的具体作用我们留到后面分析，我们暂且可以把SqlNode的作用理解为一个sql对象，这个对象可以根据输入内容生成对应的sql语句。看到这里，我们可以猜测一下，在执行动态sql构建的时候，动态sql的构建是根据List<SqlNode>一步一步创建sql拼接而成的。其实我们从接下里的SqlSource构建过程也可以看出，所有的SqlNode节点会被封装成一个MixedSqlNode节点，这个节点算是所有的SqlNode的一个外观节点：

public class MixedSqlNode implements SqlNode {
  private final List<SqlNode> contents;

  public MixedSqlNode(List<SqlNode> contents) {
    this.contents = contents;
  }

  @Override
  public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : contents) {
      sqlNode.apply(context);
    }
    return true;
  }
}

生成的MixedSqlNode对象会作为SqlSource的构造方法参数被传入SqlSource，到这里，SqlSource的创建过程我们分析完了。我们继续回到上文提到的parseStatementNode()方法，在解析完各种属性，创建完SqlSource对象后，mybatis会根据解析完的参数生成一个MappedStatement对象添加到Configuration对象的mappedStatements属性中，mappedStatements是一个Map，key是节点的id(id属性会被替换成currentNamespace + "." + base)属性，value就是MappedStatement对象。
从上面的分析，我们看到了mapper节点的解析过程，接下来我们继续回到XMLMapperBuilder的parse()方法，解析完mapper节点之后，mybatis会根据mapper的namespace去寻找对应的Mapper接口，并把接口加载到Configuration的mapperRegistry属性中。这些操作在bindMapperForNamespace()方法中有体现。做完这些动作，parse()方法会调用下面三个方法做一些后续动作，这里我们不再进行详细分析。大该的作用就是将未注册的ResultMap、CacheRefs、Statements注册到Configuration中。

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();

到这里Configuration的创建过程分析完了，大家是不是感到很乱?我把Configuration的几个比较重要的属性加了注释，来方便大家理解：

public class Configuration {

    /**
     * 加载配置文件中的<environment></environment>节点产生的对象，
     * 对象持有transactionFactory和dataSource
     */
    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;
    protected boolean useActualParamName = true;
    protected boolean returnInstanceForEmptyRow;

    protected String logPrefix;
    protected Class <? extends Log> logImpl;
    protected Class <? extends VFS> vfsImpl;
    protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
    protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
    protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));
    protected Integer defaultStatementTimeout;
    protected Integer defaultFetchSize;
    protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
    protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
    protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;

    /**
     * <properties></properties>节点解析出的值
     */
    protected Properties variables = new Properties();
    protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();

    /**
     * 解析的<objectFactory></objectFactory>节点生成的objectFactory对象，有默认值
     */
    protected ObjectFactory objectFactory = new DefaultObjectFactory();
    protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();

    protected boolean lazyLoadingEnabled = false;
    protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL

    /**
     * 根据environment节点下配置的DataSource获取的数据源id
     */
    protected String databaseId;
    /**
     * Configuration factory class.
     * Used to create Configuration for loading deserialized unread properties.
     *
     * @see <a href='https://code.google.com/p/mybatis/issues/detail?id=300'>Issue 300 (google code)</a>
     */
    protected Class<?> configurationFactory;

    /**
     * 通过类方式（或者扫描包）方式注册的Mapper类接口和通过xml文件注册的namespace对应的接口
     */
    protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

    /**
     * 解析的<plugins></plugins>节点注册的插件
     */
    protected final InterceptorChain interceptorChain = new InterceptorChain();

    /**
     * /mapper/parameterMap节点下的typeHandler属性，默认会有一些通用的typeHandler
     */
    protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
    /**
     *<typeAliases></typeAliases>节点解析出来的别名信息
     */
    protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();

    protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();

    /**
     * 解析的insert、update、delete、select节点，id为 namespace + "." + id
     */
    protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
    protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");

    /**
     * 解析的<resultMap></resultMap>节点，id为 namespace + "." + id
     */
    protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");

    /**
     * 解析的<parameterMap></parameterMap>节点，id为 namespace + "." + id
     */
    protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");

    /**
     * 解析的insert、update、delete、select节点中的<SelectKey></SelectKey>节点，
     * key是父节点id(insert、update、delete、select这些节点的id)+"!selectKey"
     */
    protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");

    /**
     * 已经加载的资源，(xml文件和Class，xml文件添加namespace，Class添加类名)
     */
    protected final Set<String> loadedResources = new HashSet<String>();
    protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");

    protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
    protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
    protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
    protected final Collection<MethodResolver> incompleteMethods = new LinkedList<MethodResolver>();

    /*
     * A map holds cache-ref relationship. The key is the namespace that
     * references a cache bound to another namespace and the value is the
     * namespace which the actual cache is bound to.
     */
    protected final Map<String, String> cacheRefMap = new HashMap<String, String>();
}

SqlSessionFactoryBuilder创建SqlSessionFactory的过程其实最主要是解析配置并生成Configuration对象的过程，创建完Configuration对象之后，SqlSessionFactoryBuilder直接调用DefaultSqlSessionFactory的构造方法来创建SqlSessionFactory对象。

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

到此我们对Mybatis启动过程中加载配置文件有了一定的了解，后面我们会继续分析mybatis的源码。