摘要：不是線程安全的，所以在使用的時候一定要保證他是局部變量。他對應的類圖如下有幾種常見的實現是默認的非線程安全的實現是中對的線程安全實現，在內部是使用的的形式來保證線程安全的是的核心。是線程安全的，可以被多個或映射器所共享使用。

SqlSessionFactory

每一個MyBatis應用都是以一個SqlSessionFactory的實例為核心構建的。SqlSessionFactory的核心作用是什么？

從類的名稱上可以看出來，SqlSessionFactory是產生SqlSession的工廠。SqlSessionFactory是通過SqlSessionFactoryBuilder這個構建器來構建的。

SqlSessionFactory是一個接口，其中定義了獲取SqlSession的方法。

public interface SqlSessionFactory {
    //獲取一個SqlSession
    SqlSession openSession();
    //獲取一個SqlSession,參數設置事務是否自動提交
    SqlSession openSession(boolean var1);
    //通過指定Connection中的參數獲取
    SqlSession openSession(Connection var1);
    //獲取SqlSession,設置事務的隔離級別，NONE(0)，READ_COMMITTED(2),READ_UNCOMMITTED(1),REPEATABLE_READ(4),SERIALIZABLE(8);
    SqlSession openSession(TransactionIsolationLevel var1);
    //獲取SqlSession，同時制定執行的類別，支持三種SIMPLE(這種模式下，將為每個語句創建一個PreparedStatement),REUSE(這個模式下重復使用preparedStatment),BATCH(批量更新，insert時候，如果沒有提交，無法獲取自增id);
    SqlSession openSession(ExecutorType var1);
    SqlSession openSession(ExecutorType var1, boolean var2);
    SqlSession openSession(ExecutorType var1, TransactionIsolationLevel var2);
    SqlSession openSession(ExecutorType var1, Connection var2);
    //獲取所有的配置項
    Configuration getConfiguration();
}

SqlSessionFactory包含兩個實現：DefaultSqlSessionFactory和SqlSessionManager
SqlSessionFactory的實例如何創建呢？
1、通常我們是在只有MyBatis的項目中是使用下面的代碼段來創建的：

String resource = "org/mybatis/example/mybatis-config.xml";
//讀取mybatis配置的問題
InputStream inputStream = Resources.getResourceAsStream(resource);
//通過SqlSessionFactoryBuilder的build方式創建
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

2、在Spring boot和MyBatis結合的項目中我會使用下面的代碼段來創建：

MyBatis-Spring-Boot-Starter依賴將會提供如下

自動檢測現有的DataSource

將創建并注冊SqlSessionFactory的實例，該實例使用SqlSessionFactoryBean將該DataSource作為輸入進行傳遞

將創建并注冊從SqlSessionFactory中獲取的SqlSessionTemplate的實例。

自動掃描您的mappers，將它們鏈接到SqlSessionTemplate并將其注冊到Spring上下文，以便將它們注入到您的bean中。

就是說，使用了該Starter之后，只需要定義一個DataSource即可（application.properties中可配置），它會自動創建使用該DataSource的SqlSessionFactory Bean以及SqlSessionTemplate。會自動掃描你的Mappers，連接到SqlSessionTemplate，并注冊到Spring上下文中.

@Bean
public SqlSessionFactory sqlSessionFactory(@Qualifier("druidDataSource") DataSource druidDataSource) throws Exception {
    //先創建一個SqlSessionFactoryBean
    SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
    //在這個bean里設置需要的參數
    fb.setDataSource(this.dynamicDataSource(druidDataSource));
    fb.setTypeAliasesPackage(env.getProperty("mybatis.type-aliases-package"));
    fb.setTypeHandlersPackage(env.getProperty("mybatis.type-handlers-package"));
    fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapperLocations")));
    //通過這個方法獲取一個SqlSessionFactory
    return fb.getObject();
}

在代碼里一直向下查找的時候就會發現：這個過程其實和上面的過程一樣。
SqlSessionFactoryBean會將一系列的屬性封裝成一個Configuration對象，然后調用
this.sqlSessionFactoryBuilder.build(configuration) 來創建。而在sqlSessionFactoryBuilder里主要就是解析資源的內容，然后進行創建。

在這里有分別使用了兩個設計模式：

工廠模式

SqlSessionFactory就是一個工廠模式——簡單工廠模式的變形實現。
通過SqlSessionFactory中重載的不同openSession()方法來獲取不同類型的實例。

建造者模式（build模式）

SqlSessionFactoryBuilder創建SqlSessionFactory就是建造者模式的實現。在創建的過程中需要解析很多的文件，生成對象，進行緩存等操作，所以一個方法是很難直接寫完，所以其中應用了大量的build模式：

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
    XMLConfigBuilder xmlConfigBuilder = null;
    Configuration configuration;
    if (this.configuration != null) {
       ......
    } else if (this.configLocation != null) {
        xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), (String)null, this.configurationProperties);
        configuration = xmlConfigBuilder.getConfiguration();
    } else {
        ......
    }
    ......

    if (xmlConfigBuilder != null) {
        try {
            //builder解析
            xmlConfigBuilder.parse();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Parsed configuration file: "" + this.configLocation + """);
            }
        } catch (Exception var22) {
            throw new NestedIOException("Failed to parse config resource: " + this.configLocation, var22);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    ......
    if (!ObjectUtils.isEmpty(this.mapperLocations)) {
        Resource[] var29 = this.mapperLocations;
        var27 = var29.length;

        for(var5 = 0; var5 < var27; ++var5) {
            Resource mapperLocation = var29[var5];
            if (mapperLocation != null) {
                try {
                    //Mapper文件build
                    XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(), configuration, mapperLocation.toString(), configuration.getSqlFragments());
                    xmlMapperBuilder.parse();
                } catch (Exception var20) {
                    
                } finally {
                    //單例模式
                    ErrorContext.instance().reset();
                }
            }
        }
    } 
    //build一個對象返回
    return this.sqlSessionFactoryBuilder.build(configuration);
}

SqlSession

SqlSessionFactory創建完成之后，就可以通過SqlSessionFactory對象來獲取一個SqlSession實例.SqlSession是一次與數據庫的會話.在他的接口中定義了一些列的CRUD和事務的操作接口。SqlSession是暴露給用戶使用的API,一個SqlSession對應著一次數據庫會話。SqlSession不是線程安全的，所以在使用的時候一定要保證他是局部變量。
他對應的類圖如下：

SqlSession有幾種常見的實現：DefaultSqkSession是默認的非線程安全的實現,SqlSessionManager是Mybatis中對SqlSession的線程安全實現，在內部是使用的private ThreadLocal localSqlSession = new ThreadLocal();的形式來保證線程安全的,SqlSessionTemplate是MyBatis-Spring 的核心。作為 SqlSession 的一個實現，這意味著可以使用它無縫代替你代碼中已經在使用的 SqlSession。SqlSessionTemplate 是線程安全的，可以被多個 DAO 或映射器所共享使用。

因為SqlSessionTemplate是線程安全的，所以當SqlSessionTemplate是單例的時候，多線程調用SqlSessionTemplate仍然使用的是同一個SqlSession,接下來看一下SqlSessionTemplate是如何保證線程安全的呢？

首先我們看一下SqlSessionTemplate的創建過程：

/**
 * 構造函數1，需要傳入參數SqlSessionFactory
 */
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
    this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
    Assert.notNull(sqlSessionFactory, "Property "sqlSessionFactory" is required");
    Assert.notNull(executorType, "Property "executorType" is required");
    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
    //創建代理類的實例，該代理類實現了SqlSession接口，這里使用的是基于JDK的動態代理，SqlSessionInterceptor也是實現了InvocationHandler接口，最后代理對象的操作都會經過invoke執行
    //class SqlSessionInterceptor implements InvocationHandler
    this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
}

invoke的實現是實現線程安全的核心：

private class SqlSessionInterceptor implements InvocationHandler {
    private SqlSessionInterceptor() {
    }
  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     //獲取真實的SqlSession，這個是真實使用的，是MyBatis生成的DefaultSqlSession,獲取是線程安全實現的核心
        SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

        Object unwrapped;
        try {
            //執行操作
            Object result = method.invoke(sqlSession, args);
            //如果不是事務類型的，那么設置為自動提交
            if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
                sqlSession.commit(true);
            }
            //執行結果包裝
            unwrapped = result;
        } catch (Throwable var11) {
            unwrapped = ExceptionUtil.unwrapThrowable(var11);
            if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
                SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                sqlSession = null;
                Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
                if (translated != null) {
                    unwrapped = translated;
                }
            }

            throw (Throwable)unwrapped;
        } finally {
            if (sqlSession != null) {
                SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
            }

        }
        //返回執行結果
        return unwrapped;
    }
}

接著看getSqlSession()的代碼：

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
    Assert.notNull(sessionFactory, "No SqlSessionFactory specified");
    Assert.notNull(executorType, "No ExecutorType specified");
    //SqlSessionHolder是對SqlSession的一個功能包裝，TransactionSynchronizationManager是一個事務同步管理器，維護當前線程事務資源，信息以及TxSync集合，getResource會從 ThreadLocal> resources 中獲取當前線程SqlSessionHolder實例
    SqlSessionHolder holder = (SqlSessionHolder)TransactionSynchronizationManager.getResource(sessionFactory);
    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
        return session;
    } else {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Creating a new SqlSession");
        }
        //如果沒有獲取成功，那么開啟一個SqlSession
        session = sessionFactory.openSession(executorType);
        //注冊SessionHolder
        registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
        return session;
    }
}

registerSessionHolder()實現？

好難啊～～～～～