Mybatis中的SqlSessionFactory的获取过程(用debug跟下来的结果)

当在配置完Mybatis的映射文件后，我们一般所需要做的操作就是写一个工具类用来专门获取SqlSessionFactory，这里是我自己所写的类专门用来获取，而且要明白每个库要获取事务都需要获取SqlSessionFactory对象，所以一般都可以单独的抽出来写一个工具类：

public class DButils {
	public static String resource="mybatis-config.xml";
	public static InputStream inputStream=null;
	public static SqlSessionFactory sqlSessionFactory=null;
	static {
		try {
			inputStream=Resources.getResourceAsStream(resource);
			sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static SqlSessionFactory getSqlSessionFactory() {
		if(sqlSessionFactory==null) {
			try {
				inputStream=Resources.getResourceAsStream(resource);
				sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sqlSessionFactory;
	}
}

但是这样不足够，这只是简单的获取，所以接下来我们要讨论的是如何获取SqlSessionFactory的具体过程：
——————————————————————————————————————————
第一步：
在测试方法处在这里inputStream=Resources.getResourceAsStream(resource);打断点，一直往下跟后，直到：

SqlSession session=sessionFactory.openSession();
这里是由于我将下面语句分开写得到——————
>>sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);<<

我们会发现我们会跳进DefaultSqlSession这个类，这里面会有一个openSession重写的方法，：

@Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

——————————————————————————————————————————
再次跳进我们会发现这个方法：返回一个默认的执行器类型，这时候也会拿到configuration的哈希

public ExecutorType getDefaultExecutorType() {
    return defaultExecutorType;
  }

当返回到openSession方法后执行到return语句时，可以再次跳进看看里面到底是什么？

  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();
    }
  }

我们可以看到跳进之后的方法实现：

openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false)

的作用简单来说是用来从数据源打开事务session，(openSessionFromDataSource)需要传入三个参数（1.执行器类型；2.事务隔离级别；3.自动提交判断）

什么是事务隔离级别？
首先我们得明白Java中一般有三种读写方式：读多写少、写多读少、读写一致
在数据库操作中，为了有效的保证并发读取数据的正确性，提出了事务隔离级别；由于在数据库操作中可能出现以下的不确定性（1.更新丢失；2.脏读；3.不可重复读），所以在标准的SQL规范中定义了四个事务隔离级别：
1.读未提交(Read Uncommitted):允许脏读，但不允许更新丢失。如果一个事务已经开始写数据，则另一个事务不允许同时写操作，但允许其他事务读此行数据。
2.读提交(Read Committed):允许不可重复读取，但不允许脏读。读取数据的事务允许其他事务继续访问该行数据，当时未提交的写事务将会禁止其他事务访问该行；对于大多数程序可以优先考虑把数据库的隔离级别设置为此级别；
3.可重复读取(Repeatable Read):禁止不可重复读取和脏读，但是有时可能出现幻读数据。读取数据的事务将会禁止写事务（但允许读），写事务则禁止任何其他事务，相对来说可重复读取比较适合读多写少的数据库；
4.序列化(Serializable):提供严格的事务隔离。他要求严格的序列化执行，即事务只能一个接一个的执行，不能并发执行；

这里默认传入的三个数据为：
execType(执行器类型)：name(名字)=‘SIMPLE’+ordinal(序号)=0；
level(事务隔离级别)：null
autoCommit(自动提交)：false——这样才有了我们后来对事务的手动提交

——————————————————————————————————————————

接下来往下执行语句

final Environment environment = configuration.getEnvironment();

执行就可以得到环境environment其中包含：
dataSource(数据源)——(PooledDataSource)带池的数据源
id——对应config.xml文件中的environment
transcationFactory(事务工厂)——对应config.xml文件中的事务管理——JDBCTransactionFactory

———————————————————————————————————————————

当拿到environment后改语句自动结束，开始下一行代码（获取事务工厂）执行：

      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);

跳进此方法后源码为：

private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
    if (environment == null || environment.getTransactionFactory() == null) {
      return new ManagedTransactionFactory();
    }
    return environment.getTransactionFactory();
  }

首先我们发现此方法也在DefaultSqlSessionFactory中，所以与上面的代码属于同级，首先会执行
条件判断:
if (environment == null || environment.getTransactionFactory() == null),由于environment在之前已经拿到所以不为空，就将进入
return environment.getTransactionFactory()中的environment.getTransactionFactory()方法，此方法源码如下返回一个当前对象的事务工厂：

public TransactionFactory getTransactionFactory() {
    return this.transactionFactory;
  }

从而使final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);顺利拿到事务工厂；
———————————————————————————————————————————
接下来执行语句：

  tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

依据传入的参数类型可以知道首先调用：environment.getDataSource()函数，传入level和自动提交判断，这里就不再强调了；当传入参数完毕后，开始执行函数：

 transactionFactory.newTransaction()

此方法在类class JdbcTransactionFactory implements TransactionFactory，该类实现了TransactionFactory接口，通过重写newTranscation()方法返回一个连接事务：

  @Override
  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }

中间会夹杂者一些类的加载机制，最后跳进方法体，赋予变量值：

public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
    dataSource = ds;
    level = desiredLevel;
    autoCommit = desiredAutoCommit;
  }

到这里，变量tx已经设置完成，如下所示：

——————————————————————————————————————————
接着执行语句：final Executor executor = configuration.newExecutor(tx, execType);
此函数的源码为，为了方便我给每行源码标号：

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    (1) executorType = executorType == null ? defaultExecutorType : executorType;
    (2) executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    (3) Executor executor;
    (4) if (ExecutorType.BATCH == executorType) {
      		executor = new BatchExecutor(this, transaction);
    	} else if (ExecutorType.REUSE == executorType) {
      		executor = new ReuseExecutor(this, transaction);
    	} else {
      		executor = new SimpleExecutor(this, transaction);
    	}
    (5) if (cacheEnabled) {
      		executor = new CachingExecutor(executor);
    	}
   （6） executor = (Executor) interceptorChain.pluginAll(executor);
    		return executor;
  		}

(1)(2)三元表达式判断执行器类型,分别有分批处理类型、复用类型、简单执行器
(3)由于此时的执行器为简单执行器，所以直接跳到函数：
executor = new SimpleExecutor(this, transaction)，传入当前对象和事务；
首先通过底层实现类加载(ClassLoader)

由于SimpleExecutor类继承自BaseExecutor类，所以子类Simple调用父类super(this,transaction)

public class SimpleExecutor extends BaseExecutor {

  public SimpleExecutor(Configuration configuration, Transaction transaction) {
    super(configuration, transaction);
  }

而父类BaseExecutor的构造函数为：

protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

其中包含对transaction的赋值，延迟加载，本地缓存(HashMap)，本地输出参数缓存，关闭，配置，包装器

之后进入(5),cacheEnabled默认使true，所以进入if判断之中，执行executor = new CachingExecutor(executor)函数，在这实现类TransformManager.transform(classLoader,String,ProtectionDomain,byte[],boolean),最终拿到当前类对象的配置Configeration，事务transaction，执行器类型excutorType，执行器excutor；

而此时执行类CashingExcutor中的构造函数（缓存+动态代理）

 public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }

拿到缓存执行器和简单执行器：

之后跳进到语句（6）executor = (Executor) interceptorChain.pluginAll(executor)为执行器添加监察功能；
继续执行返回executor；
此时，方法SqlSession openSessionFromDataSource()已经执行完毕，返回DefaultSqlSession给上一级方法SqlSession openSqlSession(),到最后会拿到defaultSqlSessionFactory的所有东西（主要是拿到了SqlSessionFactory实例对象），最终返回SqlSessionFactory给实例对象在openSession；

———————————————————————————————————————————