mybatis源碼解析2---SqlSessionFactoryBuilder、SqlSessionFactory解析

1.先看一個mybatis最簡單的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都是什么，是怎么工作的？

一、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的默認實現類）