1. 简单Demo

String resource = "mybatis-config.xml";
//1.流形式读取mybatis配置文件
InputStream stream = Resources.getResourceAsStream(resource); 
//2.通过配置文件创建SqlSessionFactory
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(stream);
//3.通过SqlSessionFactory创建sqlSession
SqlSession session = sessionFactory.openSession();
//4.通过SqlSession执行Sql语句获取结果
List<User> userList = session.selectList("selectAll");
System.out.println(userList.size());

1.通过InputStream获取mybatis的配置文件
2.通过SqlSessionFactoryBuilder创建SqlSessionFactory
3.通过SqlSessionFactory创建一个SqlSession
4.通过SqlSession执行Sql语句并获取结果
那么接下来先来了解下SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession都是什么，是怎么工作的？

2. SqlSessionFactoryBuilder 分析

SqlSessionFactoryBuilder是SqlSessionFactory的构造类，而SqlSessionFactory又是SqlSession的工厂接口，SqlSession从字面意思可知是sql会话接口；
所以SqlSessionFactoryBuilder可定义为Sql会话工厂构造类，顾名思义此类的作用就是创建SqlSessionFactory

package org.apache.ibatis.session;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Properties;
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.exceptions.ExceptionFactory;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
public class SqlSessionFactoryBuilder {
    //方法1
    public SqlSessionFactory build(Reader reader) {
        return build(reader, null, null);
    }
    //方法2
    public SqlSessionFactory build(Reader reader, String environment) {
        return build(reader, environment, null);
    }
    //方法3
    public SqlSessionFactory build(Reader reader, Properties properties) {
        return build(reader, null, properties);
    }
    //方法4
    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
            ErrorContext.instance().reset();
            try {
                reader.close();
            } catch (IOException e) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }
    //方法5
    public SqlSessionFactory build(InputStream inputStream) {
        return build(inputStream, null, null);
    }
    //方法6
    public SqlSessionFactory build(InputStream inputStream, String environment) {
        return build(inputStream, environment, null);
    }
    //方法7
    public SqlSessionFactory build(InputStream inputStream, Properties properties) {
        return build(inputStream, null, properties);
    }
    //方法8
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            // 解析mybatis的xml配置文件，封装为Configuration对象
            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.
            }
        }
    }
    //方法9
    public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
    }

由源码可知该类共有9个public方法，方法1、2、3最终都是调用了方法4；而方法5、6、7最终都是调用了方法8；而方法4和方法8都是根据传参创建了一个XMLConfiguration对象。
然后根据XMLConfiguration对象的parse方法创建了一个Configuration对象，然后都调用了方法9，所以该类的所有方法最终都是调用了方法9。而方法9是根据传入的Configuration参数新建了一个DefaultSqlSessionFactory对象返回。
很显然DefaultSqlSessionFactory是SqlSessionFactory接口的默认实现类（SqlSessionFactory还有一个SqlSessionManager实现类，后续继续了解）
总结：SqlSessionFactoryBuilder根据mybatis的配置文件流创建Configuration对象，然后新建一个SqlSessionFactory的默认实现类DefaultSqlSessionFactory的对象

3. SqlSessionFactory 分析

package org.apache.ibatis.session;
import java.sql.Connection;
/**
     * Creates an {@link SqlSession} out of a connection or a DataSource
     * 
     * @author Clinton Begin
     */
public interface SqlSessionFactory {
    SqlSession openSession();
    SqlSession openSession(boolean autoCommit);
    SqlSession openSession(Connection connection);
    SqlSession openSession(TransactionIsolationLevel level);
    SqlSession openSession(ExecutorType execType);
    SqlSession openSession(ExecutorType execType, boolean autoCommit);
    SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
    SqlSession openSession(ExecutorType execType, Connection connection);
    /**
     * 获取Configuration 对象，这个对象包含了MyBatis的配置信息，Mapper接口等信息的描述
     * @return MyBatis配置信息
     */
    Configuration getConfiguration();
}

SqlSessionFactory接口定义了8个创建SqlSession的接口，和一个获取Configuration的方法，该接口的主要作用也就是创建SqlSession
可以看出这里面涉及到了几个参数：
autoCommit：数据库是否自动提交
Connection：数据库连接
TransactionIsolationLevel：数据库隔离级别
ExecutorType：执行器类型
这几个参数具体含义暂不讨论，后续继续了解，那么现在继续了解下SqlSessionFactory的默认实现类DefaultSqlSessionFactory

4. DefaultSqlSessionFactory 分析

package org.apache.ibatis.session.defaults;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.ibatis.exceptions.ExceptionFactory;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
/**
 * @author Clinton Begin
 */
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private final Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }
    @Override
    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
    @Override
    public SqlSession openSession(boolean autoCommit) {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
    }
    @Override
    public SqlSession openSession(ExecutorType execType) {
        return openSessionFromDataSource(execType, null, false);
    }
    @Override
    public SqlSession openSession(TransactionIsolationLevel level) {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
    }
    @Override
    public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
        return openSessionFromDataSource(execType, level, false);
    }
    @Override
    public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
        return openSessionFromDataSource(execType, null, autoCommit);
    }
    @Override
    public SqlSession openSession(Connection connection) {
        return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
    }
    @Override
    public SqlSession openSession(ExecutorType execType, Connection connection) {
        return openSessionFromConnection(execType, connection);
    }
    @Override
    public Configuration getConfiguration() {
        return configuration;
    }
    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        Transaction tx = null;
        try {
            final Environment environment = configuration.getEnvironment();
            final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            final Executor executor = configuration.newExecutor(tx, execType);
            return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
            closeTransaction(tx); // may have fetched a connection so lets call close()
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
        try {
            boolean autoCommit;
            try {
                autoCommit = connection.getAutoCommit();
            } catch (SQLException e) {
                // Failover to true, as most poor drivers
                // or databases won't support transactions
                autoCommit = true;
            }      
            final Environment environment = configuration.getEnvironment();
            final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
            final Transaction tx = transactionFactory.newTransaction(connection);
            final Executor executor = configuration.newExecutor(tx, execType);
            return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
        if (environment == null || environment.getTransactionFactory() == null) {
            return new ManagedTransactionFactory();
        }
        return environment.getTransactionFactory();
    }
    private void closeTransaction(Transaction tx) {
        if (tx != null) {
            try {
                tx.close();
            } catch (SQLException ignore) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }
}

DefaultSqlSessionFactory除了实现了SqlSessionFactory的9个接口，还有一个构造方法，也就是SqlSessionFactoryBuilder中调用的那个，然后还有4个私有方法。
可以看出实现的8个创建SqlSession对象的接口最终都是调用了openSessionFromDataSource()或是openSessionFromConnection()两个方法，以openSessionFromDataSource()为例，源码如下：

4.1. openSessionFromDataSource()

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
        //根据Configuration获取环境参数对象
        final Environment environment = configuration.getEnvironment();
        //根据环境参数对象获取事务工厂对象
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
        //根据事务工厂创建新的事务对象
        tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
        //根据Configuration获取执行器对象
        final Executor executor = configuration.newExecutor(tx, execType);
        //根据3个参数创建DefaultSqlSession对象
        return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
        closeTransaction(tx); // may have fetched a connection so lets call close()
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

openSessionFromDataSource() 共有三个参数

1. ExecutorType：执行器类型
2. TransactionIsolationLevel：事务隔离级别
3. autoCommit：自动提交标识

通过源码分析，最终是创建了一个DefaultSqlSession对象，很明显是SqlSession接口的默认实现类；
openSessionFromConnection方法和openSessionFromDataSource的区别就是参数不同，效果是一样的，最终也是返回一个DefaultSqlSession对象
而具体的Sql的执行都是通过DefaultSqlSession对象去执行的。具体怎么执行的后续再了解。
总结：
1.先获取mybatis的配置文件，解析成流对象（字符流和字节流都可以）Reader和InputStream都可以
2.通过SqlSessionFactoryBuilder根据mybatis的配置文件流创建一个Configuration对象
3.SqlSessionFactoryBuilder根据Configuration对象创建一个DefaultSqlSessionFactory（SqlSessionFactory的默认实现类）
4.DefaulatSqlSessionFacotry根据传入的参数，创建一个DefaultSqlSession对象（SqlSession的默认实现类）

5. XMLConfigBuilder 分析

XMLConfigBuilder类的作用是对mybatis-config.xml配置文件的解析，在SqlSessionFactoryBuilder 类中解析MyBatis配置文件时创建，位于org.apache.ibatis.builder.xml目录下，继承于BaseBuilder类，关于BaseBuilder类后续再看。
XMLConfigBuilder看名字能猜到是关于mybatis的XML配置的构造类，负责构造mybatis的XML配置的。
XMLConfigBuilder共有四个属性，代码如下：

  //解析标识,因为Configuration是全局变量，只需要解析创建一次即可，true表示已经解析创建过,false则表示没有
  private boolean parsed;
  private final XPathParser parser;
  //环境参数
  private String environment;
  private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

XMLConfigBuilder共有6个public构造方法和一个private的构造方法

public XMLConfigBuilder(Reader reader) {
    this(reader, null, null);
}
public XMLConfigBuilder(Reader reader, String environment) {
    this(reader, environment, null);
}
public XMLConfigBuilder(Reader reader, String environment, Properties props) {
    this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
}
public XMLConfigBuilder(InputStream inputStream) {
    this(inputStream, null, null);
}
public XMLConfigBuilder(InputStream inputStream, String environment) {
    this(inputStream, environment, null);
}
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;
}

这6个public的构造方法都是根据mybatis的配置文件流创建一个XPathParser对象，然后最终都调用了私有的构造方法，而私有的构造方法先是调用了父类BaseBuilder的构造方法，然后分别根据参数给四个属性赋值。
在SqlSessionFactoryBuilder中解析MyBatis文件是通过创建一个XMLConfigBuilder对象，然后调用了对象的parse()方法获取到一个Configuration对象。接下来就先看看XMLConfigBuilder的parse()方法，如下：

public Configuration parse() {
    //判断Configuration是否解析过，Configuration是全局变量，只需要解析创建一次即可
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    //调用下面的方法,parser.evalNode("/configuration")解析XML配置的configuration节点的内容，得到XNode对象
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}
/**
 * 根据root中存储的是configuration节点的内容
 * @param root
 */
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"));
        //设置reflectFactory配置
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        //设置environments配置
        environmentsElement(root.evalNode("environments"));
        //设置databaseIdProvider配置
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        //设置typeHandlers配置
        typeHandlerElement(root.evalNode("typeHandlers"));
        //设置mappers配置
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

可以看出parse的作用是解析mybatis-config.xml的configuration节点的内容，然后挨个赋值给configuration对象的属性。
而XMLConfigBuilder的其他私有方法都是给根据XNode对象（XML配置的configuration节点内容）来给全局配置变量configuration的属性进行赋值，关于Configuration类的解析下一章会解析

总结:XMLConfigBuilder类的作用是根据全局配置文件mybatis-config.xml的流文件进行解析,解析xml中的各个节点，然后创建一个Configuration对象，并将xml中的节点属性赋值给Configuration对象

6. Configuration 分析

Configuration类位于mybatis包的org.apache.ibatis.session目录下，是mybatis的全局变量，属性就是对应于mybatis的全局配置文件mybatis-config.xml的配置，将XML配置中的内容解析赋值到Configuration对象中。
由于XML配置项有很多，所以Configuration类的属性也很多。先来看下Configuration对于的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>    
     <!-- 属性配置,读取properties中的配置文件 -->
    <properties resource="db.propertis">
       <property name="XXX" value="XXX"/>
    </properties>
    <!-- 类型别名 -->
    <typeAliases>
       <!-- 在用到User类型的时候,可以直接使用别名,不需要输入User类的全部路径 -->
       <typeAlias type="com.luck.codehelp.entity.User" alias="user"/>
    </typeAliases>
    <!-- 类型处理器 -->
    <typeHandlers>
        <!-- 类型处理器的作用是完成JDBC类型和java类型的转换,mybatis默认已经由了很多类型处理器,正常无需自定义-->
    </typeHandlers>
    <!-- 对象工厂 -->
    <!-- mybatis创建结果对象的新实例时,会通过对象工厂来完成，mybatis有默认的对象工厂，正常无需配置 -->
    <objectFactory type=""></objectFactory>
    <!-- 插件 -->
    <plugins>
        <!-- 可以自定义拦截器通过plugin标签加入 -->
       <plugin interceptor="com.lucky.interceptor.MyPlugin"></plugin>
    </plugins>
    <!-- 全局配置参数 -->
    <settings>   
        <setting name="cacheEnabled" value="false" />   
        <setting name="useGeneratedKeys" value="true" /><!-- 是否自动生成主键 -->
        <setting name="defaultExecutorType" value="REUSE" />   
        <setting name="lazyLoadingEnabled" value="true"/><!-- 延迟加载标识 -->
        <setting name="aggressiveLazyLoading" value="true"/><!--有延迟加载属性的对象是否延迟加载 -->
        <setting name="multipleResultSetsEnabled" value="true"/><!-- 是否允许单个语句返回多个结果集 -->
        <setting name="useColumnLabel" value="true"/><!-- 使用列标签而不是列名 -->
        <setting name="autoMappingBehavior" value="PARTIAL"/><!-- 指定mybatis如何自动映射列到字段属性;NONE:自动映射;PARTIAL:只会映射结果没有嵌套的结果;FULL:可以映射任何复杂的结果 -->
        <setting name="defaultExecutorType" value="SIMPLE"/><!-- 默认执行器类型 -->
        <setting name="defaultFetchSize" value=""/>
        <setting name="defaultStatementTimeout" value="5"/><!-- 驱动等待数据库相应的超时时间 ,单位是秒-->
        <setting name="safeRowBoundsEnabled" value="false"/><!-- 是否允许使用嵌套语句RowBounds -->
        <setting name="safeResultHandlerEnabled" value="true"/>
        <setting name="mapUnderscoreToCamelCase" value="false"/><!-- 下划线列名是否自动映射到驼峰属性：如user_id映射到userId -->
        <setting name="localCacheScope" value="SESSION"/><!-- 本地缓存（session是会话级别） -->
        <setting name="jdbcTypeForNull" value="OTHER"/><!-- 数据为空值时,没有特定的JDBC类型的参数的JDBC类型 -->
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/><!-- 指定触发延迟加载的对象的方法 -->
        <setting name="callSettersOnNulls" value="false"/><!--如果setter方法或map的put方法，如果检索到的值为null时，数据是否有用  -->
        <setting name="logPrefix" value="XXXX"/><!-- mybatis日志文件前缀字符串 -->
        <setting name="logImpl" value="SLF4J"/><!-- mybatis日志的实现类 -->
        <setting name="proxyFactory" value="CGLIB"/><!-- mybatis代理工具 -->
    </settings>  
    <!-- 环境配置集合 -->
    <environments default="development">    
        <environment id="development">    
            <transactionManager type="JDBC"/><!-- 事务管理器 -->
            <dataSource type="POOLED"><!-- 数据库连接池 -->    
                <property name="driver" value="com.mysql.jdbc.Driver" />    
                <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8" />    
                <property name="username" value="root" />    
                <property name="password" value="*****" />    
            </dataSource>    
        </environment>    
    </environments>    
    <!-- mapper文件映射配置 -->
    <mappers>    
        <mapper resource="com/luck/codehelp/mapper/UserMapper.xml"/>    
    </mappers>    
</configuration>

而对于XML的配置，Configuration类的属性是和XML配置对应的。Configuration类属性如下：

protected Environment environment;
protected boolean safeRowBoundsEnabled;
protected boolean safeResultHandlerEnabled = true;
protected boolean mapUnderscoreToCamelCase;
//true：有延迟加载属性的对象被调用时完全加载任意属性;false：每个属性按需要加载
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 boolean shrinkWhitespacesInSql;
protected String logPrefix;
protected Class<? extends Log> logImpl;
protected Class<? extends VFS> vfsImpl;
protected Class<?> defaultSqlProviderType;
protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString"));
protected Integer defaultStatementTimeout;
protected Integer defaultFetchSize;
protected ResultSetType defaultResultSetType;
protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
//指定mybatis如果自动映射列到字段和属性,PARTIAL会自动映射简单的没有嵌套的结果,FULL会自动映射任意复杂的结果
protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;
protected Properties variables = new Properties();
protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
protected ObjectFactory objectFactory = new DefaultObjectFactory();
protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
//是否延时加载，false则表示所有关联对象即使加载,true表示延时加载
protected boolean lazyLoadingEnabled = false;
protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL
protected String databaseId;
/**
   * Configuration factory class.
   * Used to create Configuration for loading deserialized unread properties.
   *
   * @see <a href='https://github.com/mybatis/old-google-code-issues/issues/300'>Issue 300 (google code)</a>
   */
protected Class<?> configurationFactory;
protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
protected final InterceptorChain interceptorChain = new InterceptorChain();
protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
  .conflictMessageProducer((savedValue, targetValue) ->
                           ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
//已经加载过的resource(mapper)
protected final Set<String> loadedResources = new HashSet<>();
protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");
protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();
protected final Collection<MethodResolver> incompleteMethods = new LinkedList<>();
/*
   * 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<>();

而Configuration中的方法也差不多都是关于这些属性的set和get方法。由于属性太多，就不一一解析，现在只知道Configuration类是和mybatis的XML配置是对应的。加载的过程是SqlSessionFactoryBuilder根据xml配置的文件流，通过XMLConfigBuilder的parse方法进行解析得到一个Configuration对象。那么Configuration什么时候会用到呢？

7. SqlSession 分析

mybatis启动的时候会加载XML配置文件解析生成全局配置对象Configuration对象，SqlSessionFactoryBuilder类会根据Configuration对象创建一个DefaultSqlSessionFactory对象，而DefaultSqlSessionFactory对象实现了SqlSessionFactory中的创建SqlSession的方法，最终新建了一个SqlSession接口的默认实现类DefaultSqlSession，现在先来了解下SqlSession以及它的实现类
SqlSession解析
SqlSession位于mybatis包的org.apache.ibatis.session目录下，字面意思就是sql的会话，用于程序和数据库直接的sql会话，程序执行一次数据库操作就需要创建一个sqlSession，操作结束即关闭sqlSession；
既然是程序和数据库之间的会话，那么sqlSession接口的方法应该是程序和数据库都容易理解的，sqlSession中定义的方法都是关于数据库操作的方法，源码如下：

package org.apache.ibatis.session;
import java.io.Closeable;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.BatchResult;
public interface SqlSession extends Closeable {
    //根据Sql语句查询单条记录
    <T> T selectOne(String statement);
    <T> T selectOne(String statement, Object parameter);//根据Sql语句和参数查询单条记录
    //根据Sql语句查询多条记录
    <E> List<E> selectList(String statement);
    <E> List<E> selectList(String statement, Object parameter);//根据Sql语句和参数查询多条记录
    <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);//根据Sql语句和参数以及分页参数查询多条记录
    //selectMap和selectList原理一样,只是将结果集映射成Map对象返回
    <K, V> Map<K, V> selectMap(String statement, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
    //返回游标对象
    <T> Cursor<T> selectCursor(String statement);
    <T> Cursor<T> selectCursor(String statement, Object parameter);
    <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
    //查询的结果对象由指定的ResultHandler处理
    void select(String statement, Object parameter, ResultHandler handler);
    void select(String statement, ResultHandler handler);
    void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
    //执行insert语句
    int insert(String statement);
    int insert(String statement, Object parameter);
    //执行update语句
    int update(String statement);
    int update(String statement, Object parameter);
    //执行delete语句
    int delete(String statement);
    int delete(String statement, Object parameter);
    //提交事务
    void commit();
    void commit(boolean force);
    //事务回滚
    void rollback();
    void rollback(boolean force);
    //将请求刷新到数据库
    List<BatchResult> flushStatements();
    //关闭sqlSession
    @Override
    void close();
    //清除缓存  
    void clearCache();
    //获取Configuration对象
    Configuration getConfiguration();
    //获取Type对象的Mapper对象
    <T> T getMapper(Class<T> type);
    //获取sqlSession对象的数据库连接
    Connection getConnection();
}

SqlSession中的方法全是和数据库相关的增删改查以及事务的提交方法。
SqlSession有三个实现类，除了默认的DefaultSqlSession之外，还有SqlSessionManager和SqlSessionTemplate
接下来先看下SqlSession默认的实现类DefaultSqlSession是如何实现的。

7.1. DefaultSqlSession

DefaultSqlSession有5个属性和2个构造方法如下：

//全局配置
private final Configuration configuration;
//执行器
private final Executor executor;
//自动提交标识
private final boolean autoCommit;
private boolean dirty;
//游标列表
private List<Cursor<?>> cursorList;
/**
   * 构造方法
   * @param configuration
   * @param executor
   * @param autoCommit
   */
public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
}
/**
   * 构造方法
   * @param configuration
   * @param executor
   */
public DefaultSqlSession(Configuration configuration, Executor executor) {
    this(configuration, executor, false);
}

以selectOne()方法为例

@Override
public <T> T selectOne(String statement) {
    return this.<T>selectOne(statement, null);
}
@Override
public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.<T>selectList(statement, parameter);
    if (list.size() == 1) {
        return list.get(0);
    } else if (list.size() > 1) {
        throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
        return null;
    }
}

selectOne()最终都是调用了selectList方法，然后取唯一的一条数据返回。那在看看selectList相关的代码

@Override
public <E> List<E> selectList(String statement) {
    return this.selectList(statement, null);
}
@Override
public <E> List<E> selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        MappedStatement ms = configuration.getMappedStatement(statement);
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

共有三个selectList()方法，最终都是调用了最后一个selectList()方法，这里有三个参数：statement是sql语句、
parameter是传入的参数、RowBounds是和分页相关的参数
RowBounds源码如下：

package org.apache.ibatis.session;
/**
 * @author Clinton Begin
 */
public class RowBounds {
    public static final int NO_ROW_OFFSET = 0;
    public static final int NO_ROW_LIMIT = Integer.MAX_VALUE; //int的最大值
    public static final RowBounds DEFAULT = new RowBounds();
    private int offset;
    private int limit;
    public RowBounds() {
        this.offset = NO_ROW_OFFSET;
        this.limit = NO_ROW_LIMIT;
    }
    public RowBounds(int offset, int limit) {
        this.offset = offset;
        this.limit = limit;
    }
    public int getOffset() {
        return offset;
    }
    public int getLimit() {
        return limit;
    }
}

RowBounds的两个属性：offSet是指查询数据时从多少位置开始查询，limit是指返回数据的调试，默认是从0位置开始查询到Integer的最大值，默认是不做分页处理。
在selectList()执行如下：

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        // 获取MappedStatment对象
        MappedStatement ms = configuration.getMappedStatement(statement);
        // 通过执行器查询数据结果
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

前面讲了数据是如何查询的，我们在看看其他的insert、update、delete方法

@Override
public int insert(String statement) {
    return insert(statement, null);
}
@Override
public int insert(String statement, Object parameter) {
    return update(statement, parameter);
}
@Override
public int update(String statement) {
    return update(statement, null);
}
@Override
public int update(String statement, Object parameter) {
    try {
        dirty = true;
        MappedStatement ms = configuration.getMappedStatement(statement);
        return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}
@Override
public int delete(String statement) {
    return update(statement, null);
}
@Override
public int delete(String statement, Object parameter) {
    return update(statement, parameter);
}

可以看出SqlSession的insert和delete的方法最终都是调用了update方法，而update方法最终也是调用了Executor的update由此可得出结论sqlSession虽然叫程序和数据库之间的SQL会话，但是它并没有具体去执行sql语句，最终的sql语句的执行是由执行器Executor执行的，而SqlSession的作用只是创建了MappedStatement对象以及调用执行器去执行SQL其他的commit、rollback方法同样最终都是调用的执行器Executor的对应的方法，那么接下来就去了解下执行器Executor是如何执行的，以及SqlSession创建的MappedStatement又是什么？
DefaultSqlSession完整源码如下：

/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.session.defaults;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.binding.BindingException;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.exceptions.ExceptionFactory;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.result.DefaultMapResultHandler;
import org.apache.ibatis.executor.result.DefaultResultContext;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
/**
 *
 * The default implementation for {@link SqlSession}.
 * Note that this class is not Thread-Safe.
 *
 * @author Clinton Begin
 */
public class DefaultSqlSession implements SqlSession {
    private Configuration configuration;
    private Executor executor;
    private boolean autoCommit;
    private boolean dirty;
    private List<Cursor<?>> cursorList;
    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
    }
    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this(configuration, executor, false);
    }
    @Override
    public <T> T selectOne(String statement) {
        return this.<T>selectOne(statement, null);
    }
    @Override
    public <T> T selectOne(String statement, Object parameter) {
        // Popular vote was to return null on 0 results and throw exception on too many.
        List<T> list = this.<T>selectList(statement, parameter);
        if (list.size() == 1) {
            return list.get(0);
        } else if (list.size() > 1) {
            throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
        } else {
            return null;
        }
    }
    @Override
    public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
        return this.selectMap(statement, null, mapKey, RowBounds.DEFAULT);
    }
    @Override
    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
        return this.selectMap(statement, parameter, mapKey, RowBounds.DEFAULT);
    }
    @Override
    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
        final List<? extends V> list = selectList(statement, parameter, rowBounds);
        final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<K, V>(mapKey,
                                                                                                 configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
        final DefaultResultContext<V> context = new DefaultResultContext<V>();
        for (V o : list) {
            context.nextResultObject(o);
            mapResultHandler.handleResult(context);
        }
        return mapResultHandler.getMappedResults();
    }
    @Override
    public <T> Cursor<T> selectCursor(String statement) {
        return selectCursor(statement, null);
    }
    @Override
    public <T> Cursor<T> selectCursor(String statement, Object parameter) {
        return selectCursor(statement, parameter, RowBounds.DEFAULT);
    }
    @Override
    public <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds) {
        try {
            MappedStatement ms = configuration.getMappedStatement(statement);
            Cursor<T> cursor = executor.queryCursor(ms, wrapCollection(parameter), rowBounds);
            registerCursor(cursor);
            return cursor;
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public <E> List<E> selectList(String statement) {
        return this.selectList(statement, null);
    }
    @Override
    public <E> List<E> selectList(String statement, Object parameter) {
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
    }
    @Override
    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        try {
            MappedStatement ms = configuration.getMappedStatement(statement);
            return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public void select(String statement, Object parameter, ResultHandler handler) {
        select(statement, parameter, RowBounds.DEFAULT, handler);
    }
    @Override
    public void select(String statement, ResultHandler handler) {
        select(statement, null, RowBounds.DEFAULT, handler);
    }
    @Override
    public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
        try {
            MappedStatement ms = configuration.getMappedStatement(statement);
            executor.query(ms, wrapCollection(parameter), rowBounds, handler);
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public int insert(String statement) {
        return insert(statement, null);
    }
    @Override
    public int insert(String statement, Object parameter) {
        return update(statement, parameter);
    }
    @Override
    public int update(String statement) {
        return update(statement, null);
    }
    @Override
    public int update(String statement, Object parameter) {
        try {
            dirty = true;
            MappedStatement ms = configuration.getMappedStatement(statement);
            return executor.update(ms, wrapCollection(parameter));
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public int delete(String statement) {
        return update(statement, null);
    }
    @Override
    public int delete(String statement, Object parameter) {
        return update(statement, parameter);
    }
    @Override
    public void commit() {
        commit(false);
    }
    @Override
    public void commit(boolean force) {
        try {
            executor.commit(isCommitOrRollbackRequired(force));
            dirty = false;
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public void rollback() {
        rollback(false);
    }
    @Override
    public void rollback(boolean force) {
        try {
            executor.rollback(isCommitOrRollbackRequired(force));
            dirty = false;
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error rolling back transaction.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public List<BatchResult> flushStatements() {
        try {
            return executor.flushStatements();
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error flushing statements.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    @Override
    public void close() {
        try {
            executor.close(isCommitOrRollbackRequired(false));
            closeCursors();
            dirty = false;
        } finally {
            ErrorContext.instance().reset();
        }
    }
    private void closeCursors() {
        if (cursorList != null && cursorList.size() != 0) {
            for (Cursor<?> cursor : cursorList) {
                try {
                    cursor.close();
                } catch (IOException e) {
                    throw ExceptionFactory.wrapException("Error closing cursor.  Cause: " + e, e);
                }
            }
            cursorList.clear();
        }
    }
    @Override
    public Configuration getConfiguration() {
        return configuration;
    }
    @Override
    public <T> T getMapper(Class<T> type) {
        return configuration.<T>getMapper(type, this);
    }
    @Override
    public Connection getConnection() {
        try {
            return executor.getTransaction().getConnection();
        } catch (SQLException e) {
            throw ExceptionFactory.wrapException("Error getting a new connection.  Cause: " + e, e);
        }
    }
    @Override
    public void clearCache() {
        executor.clearLocalCache();
    }
    private <T> void registerCursor(Cursor<T> cursor) {
        if (cursorList == null) {
            cursorList = new ArrayList<Cursor<?>>();
        }
        cursorList.add(cursor);
    }
    private boolean isCommitOrRollbackRequired(boolean force) {
        return (!autoCommit && dirty) || force;
    }
    private Object wrapCollection(final Object object) {
        if (object instanceof Collection) {
            StrictMap<Object> map = new StrictMap<Object>();
            map.put("collection", object);
            if (object instanceof List) {
                map.put("list", object);
            }
            return map;
        } else if (object != null && object.getClass().isArray()) {
            StrictMap<Object> map = new StrictMap<Object>();
            map.put("array", object);
            return map;
        }
        return object;
    }
    public static class StrictMap<V> extends HashMap<String, V> {
        private static final long serialVersionUID = -5741767162221585340L;
        @Override
        public V get(Object key) {
            if (!super.containsKey(key)) {
                throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + this.keySet());
            }
            return super.get(key);
        }
    }
}