String resource = "mybatis-config.xml";
Reader reader;
//将XML配置文件构建为Configuration配置类
reader = Resources.getResourceAsReader(resource);
// 通过加载配置文件流构建一个SqlSessionFactory  DefaultSqlSessionFactory
SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
// 数据源 执行器  DefaultSqlSession
SqlSession session = sqlMapper.openSession();
//解析配置类
XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
//其底层就是专门用来解析xml的，xml里面的任何一个配置文件，都是通过node存储的
//可以通过node来获取里面的属性和里面的值，可以获取配置文件下面的所有的值
Node node = (Node)new XPathParser();
//调用parse方法解析 这个全局配置文件
parser.parse()
//解析mybatis-config.xml的node节点
parseConfiguration(parser.evalNode("/configuration"))

SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);

public class Configuration {
    //环境
  protected Environment environment;  
  protected boolean safeRowBoundsEnabled;
  protected boolean safeResultHandlerEnabled = true;
  protected boolean mapUnderscoreToCamelCase;
  protected boolean aggressiveLazyLoading;
  protected boolean multipleResultSetsEnabled = true;
  protected boolean useGeneratedKeys;
  protected boolean useColumnLabel = true;
    //缓存
  protected boolean cacheEnabled = true;
  protected boolean callSettersOnNulls;
  protected boolean useActualParamName = true;
  protected boolean returnInstanceForEmptyRow;
    ...
}

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
        //获取配置文件
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
        //解析配置文件
        return build(parser.parse());
    }finally{
        reader.close();
    }
}

public Configuration parse() {
  parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
    //解析properties标签
    propertiesElement(root.evalNode("properties"));
    //解析settings标签
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    //解析environments环境标签
    environmentsElement(root.evalNode("environments"));
    //解析typeAliases别名标签
    typeAliasesElement(root.evalNode("typeAliases"));
    //解析typeHandlers标签
    typeHandlerElement(root.evalNode("typeHandlers"));
    //解析mappers标签
    mapperElement(root.evalNode("mappers"));
}

private void propertiesElement(XNode context) throws Exception {
  if (context != null) {
        //获取子结点
    Properties defaults = context.getChildrenAsProperties();
    //获取资源
        String resource = context.getStringAttribute("resource");
        //最后将这个Properties对象加入到这个configuration的配置文件里面
        configuration.setVariables(defaults);
    }
}

<mappers>
    <package name="com.tuling.mapper"/>
</mappers>

private void mapperElement(XNode parent) throws Exception {
    //创建读取XmlMapper构建器对象
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
    //开始真正的解析mapper的xml文件
    mapperParser.parse();
}

public void parse() {
    //获取mapper映射文件的所有内容，并对映射文件进行解析
  configurationElement(parser.evalNode("/mapper"));
}

private void configurationElement(XNode context) {
    //会先解析mapper标签里面的这个namespace的这个标签
    String namespace = context.getStringAttribute("namespace");
    //设置到这个build的助手里面
    builderAssistant.setCurrentNamespace(namespace);
    //解析当前的缓存的引用
    cacheRefElement(context.evalNode("cache-ref"));
    //解析这个二级缓存
    cacheElement(context.evalNode("cache"));
    //解析resultMapper文件
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    //解析sql片段
    sqlElement(context.evalNodes("/mapper/sql"));
    //解析数据的增删改查
    buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
}

private void cacheElement(XNode context) {
    //解析cache节点的type属性
    String type = context.getStringAttribute("type", "PERPETUAL");
    //根据type的String获取class类型
    Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
    //获取缓存过期策略:默认是LRU
    String eviction = context.getStringAttribute("eviction", "LRU");
    Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
    //flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。
    Long flushInterval = context.getLongAttribute("flushInterval");
    //size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。
    Integer size = context.getIntAttribute("size");
    //只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false
    boolean readWrite = !context.getBooleanAttribute("readOnly", false);
    boolean blocking = context.getBooleanAttribute("blocking", false);
    Properties props = context.getChildrenAsProperties();
    //把缓存节点加入到Configuration中
    builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
}

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
        //解析增删改查结点
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
      statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        configuration.addIncompleteStatement(statementParser);
      }
    }
}