mybatis源码学习2--SqlSessionFactoryBuilder、SqlSessionFactory解析

1.先看一个mybatis最简单的Demo

    public void test1() throws IOException {
		//配置文件的类路径，就是target/classes目录下的路径
        String resource = "com/alipay/mybatis/mybatis-config/mybatis-config.xml";
        //1.流形式读取mybatis配置文件
        InputStream is = Resources.getResourceAsStream(resource);
        //2.通过配置文件创建SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //3.通过SqlSessionFactory创建sqlSession
        SqlSession sqlSession = factory.openSession();
		//4.通过SqlSession执行Sql语句获取结果
        User user = sqlSession.selectOne("com.alipay.mybatis.mapper.UserMapper.selectById", 2);

        System.out.println(user);

    }

1.通过InputStream获取mybatis的配置文件

2.通过SqlSessionFactoryBuilder创建SqlSessionFactory

3.通过SqlSessionFactory创建一个SqlSession

4.通过SqlSession执行Sql语句并获取结果

那么接下来先来了解下SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession都是什么，是怎么工作的？

一、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);
      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的对象

二、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 getConfiguration();

}

SqlSessionFactory接口定义了8个创建SqlSession的接口，和一个获取Configuration，该接口的主要作用也就是创建SqlSession

可以看出这里面涉及到了几个参数：

autoCommit：数据库是否自动提交

Connection：数据库连接

TransactionIsolationLevel：数据库隔离级别

ExecutorType：执行器类型

这几个参数具体含义暂不讨论，后续继续了解，那么现在继续了解下SqlSessionFactory的默认实现类DefaultSqlSessionFactory

三、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为例，源码如下：

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();//根据Configuration获取环境参数对象
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);//根据环境参数对象获取事务工厂对象
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);//根据事务工厂创建新的事务对象
      final Executor executor = configuration.newExecutor(tx, execType);//根据Configuration获取执行器对象
      return new DefaultSqlSession(configuration, executor, autoCommit);//根据3个参数创建DefaultSqlSession对象
    } 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();
    }
  }

该方法共有三个参数

ExecutorType：执行器类型

TransactionIsolationLevel：事务隔离级别

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的默认实现类）