共计 9109 个字符，预计需要花费 23 分钟才能阅读完成。
坐在我旁边的钟同学听说我精通 Mybatis 源码（我就想不通，是谁透漏了风声），就顺带问了我一个问题：在同一个方法中，Mybatis 多次请求数据库，是否要创建多个 SqlSession 会话？
可能最近撸多了，当时脑子里一片模糊，眼神迷离，虽然我当时回答他：如果多个请求同一个事务中，那么多个请求都在共用一个 SqlSession，反之每个请求都会创建一个 SqlSession。这是我们在平常开发中都习以为常的常识了，但我却没有从原理的角度给钟同学分析，导致钟同学茶饭不思，作为老司机的我，感到深深的自责，于是我暗自下定决心，要给钟同学一个交代。
不服跑个 demo
测试在方法中不加事务时，每个请求是否会创建一个 SqlSession：
从日志可以看出，在没有加事务的情况下，确实是 Mapper 的每次请求数据库，都会创建一个 SqlSession 与数据库交互，下面我们再看看加了事务的情况：
从日志可以看出，在方法中加了事务后，两次请求只创建了一个 SqlSession，再次证明了我上面的回答，但是仅仅这样回答是体现完全不出一个老司机应有的职业素养的，所以，我要发车了。
什么是 SqlSession
在发车之前，我们必须得先搞明白，什么是 SqlSession？
简单来说，SqlSession 是 Mybatis 工作的最顶层 API 会话接口，所有的数据库操作都经由它来实现，由于它就是一个会话，即一个 SqlSession 应该仅存活于一个业务请求中，也可以说一个 SqlSession 对应这一次数据库会话，它不是永久存活的，每次访问数据库时都需要创建它。
因此，SqlSession 并不是线程安全，每个线程都应该有它自己的 SqlSession 实例，千万不能将一个 SqlSession 搞成单例形式，或者静态域和实例变量的形式都会导致 SqlSession 出现事务问题，这也就是为什么多个请求同一个事务中会共用一个 SqlSession 会话的原因，我们从 SqlSession 的创建过程来说明这点：
从 Configuration 配置类中拿到 Environment 数据源；
从数据源中获取 TransactionFactory 和 DataSource，并创建一个 Transaction 连接管理对象；
创建 Executor 对象（SqlSession 只是所有操作的门面，真正要干活的是 Executor，它封装了底层 JDBC 所有的操作细节）；
创建 SqlSession 会话。
每次创建一个 SqlSession 会话，都会伴随创建一个专属 SqlSession 的连接管理对象，如果 SqlSession 共享，就会出现事务问题。
从源码的角度分析
源码分析从哪一步作为入口呢？如果是看过我之前写的那几篇关于 mybatis 的源码分析，我相信你不会在 Mybatis 源码前磨磨蹭蹭，迟迟找不到入口。
在之前的文章里已经说过了，Mapper 的实现类是一个代理，真正执行逻辑的是 MapperProxy.invoke()，该方法最终执行的是 sqlSessionTemplate。
org.mybatis.spring.SqlSessionTemplate：
private final SqlSession sqlSessionProxy;
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator) {
notNull(sqlSessionFactory, “Property ‘sqlSessionFactory’ is required”);
notNull(executorType, “Property ‘executorType’ is required”);
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator;
this.sqlSessionProxy = (SqlSession) newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class},
new SqlSessionInterceptor());
}
这个是创建 SqlSessionTemplate 的最终构造方法，可以看出 sqlSessionTemplate 中用到了 SqlSession，是 SqlSessionInterceptor 实现的一个动态代理类，所以我们直接深入要塞：
private class SqlSessionInterceptor implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SqlSession sqlSession = getSqlSession(
SqlSessionTemplate.this.sqlSessionFactory,
SqlSessionTemplate.this.executorType,
SqlSessionTemplate.this.exceptionTranslator);
try {
Object result = method.invoke(sqlSession, args);
if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
// force commit even on non-dirty sessions because some databases require
// a commit/rollback before calling close()
sqlSession.commit(true);
}
return result;
} catch (Throwable t) {
Throwable unwrapped = unwrapThrowable(t);
if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
// release the connection to avoid a deadlock if the translator is no loaded. See issue #22
closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
sqlSession = null;
Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
if (translated != null) {
unwrapped = translated;
}
}
throw unwrapped;
} finally {
if (sqlSession != null) {
closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
}
}
}
}
Mapper 所有的方法，最终都会用这个方法来处理所有的数据库操作，茶饭不思的钟同学眼神迷离不知道是不是自暴自弃导致撸多了，眼神空洞地望着我，问我 spring 整合 mybatis 和 mybatis 单独使用是否有区别，其实没区别，区别就是 spring 封装了所有处理细节，你就不用写大量的冗余代码，专注于业务开发。
该动态代理方法主要做了以下处理：
根据当前条件获取一个 SqlSession，此时 SqlSession 可能是新创建的也有可能是获取到上一次请求的 SqlSession；
反射执行 SqlSession 方法，再判断当前会话是否是一个事务，如果是一个事务，则不 commit；
如果此时抛出异常，判断如果是 PersistenceExceptionTranslator 且不为空，那么就关闭当前会话，并且将 sqlSession 置为空防止 finally 重复关闭，PersistenceExceptionTranslator 是 spring 定义的数据访问集成层的异常接口；
finally 无论怎么执行结果如何，只要当前会话不为空，那么就会执行关闭当前会话操作，关闭当前会话操作又会根据当前会话是否有事务来决定会话是释放还是直接关闭。
org.mybatis.spring.SqlSessionUtils#getSqlSession：
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
SqlSession session = sessionHolder(executorType, holder);
if (session != null) {
return session;
}
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“Creating a new SqlSession”);
}
session = sessionFactory.openSession(executorType);
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
return session;
}
是不是看到了不服跑个 demo 时看到的日志“Creating a new SqlSession”了，那么证明我直接深入的地方挺准确的，没有丝毫误差。在这个方法当中，首先是从 TransactionSynchronizationManager（以下称当前线程事务管理器）获取当前线程 threadLocal 是否有 SqlSessionHolder，如果有就从 SqlSessionHolder 取出当前 SqlSession，如果当前线程 threadLocal 没有 SqlSessionHolder，就从 sessionFactory 中创建一个 SqlSession，具体的创建步骤上面已经说过了，接着注册会话到当前线程 threadLocal 中。
先来看看当前线程事务管理器的结构：
public abstract class TransactionSynchronizationManager {
// …
// 存储当前线程事务资源，比如 Connection、session 等
private static final ThreadLocal<Map<Object, Object>> resources =
new NamedThreadLocal<>(“Transactional resources”);
// 存储当前线程事务同步回调器
// 当有事务，该字段会被初始化，即激活当前线程事务管理器
private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
new NamedThreadLocal<>(“Transaction synchronizations”);
// …
}
这是 spring 的一个当前线程事务管理器，它允许将当前资源存储到当前线程 ThreadLocal 中，从前面也可看出 SqlSessionHolder 是保存在 resources 中。
org.mybatis.spring.SqlSessionUtils#registerSessionHolder：
private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {
SqlSessionHolder holder;
// 判断当前是否有事务
if (TransactionSynchronizationManager.isSynchronizationActive()) {
Environment environment = sessionFactory.getConfiguration().getEnvironment();
// 判断当前环境配置的事务管理工厂是否是 SpringManagedTransactionFactory（默认）
if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“Registering transaction synchronization for SqlSession [” + session + “]”);
}
holder = new SqlSessionHolder(session, executorType, exceptionTranslator);
// 绑定当前 SqlSessionHolder 到线程 ThreadLocal 中
TransactionSynchronizationManager.bindResource(sessionFactory, holder);
// 注册 SqlSession 同步回调器
TransactionSynchronizationManager.registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));
holder.setSynchronizedWithTransaction(true);
// 会话使用次数 +1
holder.requested();
} else {
if (TransactionSynchronizationManager.getResource(environment.getDataSource()) == null) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“SqlSession [” + session + “] was not registered for synchronization because DataSource is not transactional”);
}
} else {
throw new TransientDataAccessResourceException(
“SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization”);
}
}
} else {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“SqlSession [” + session + “] was not registered for synchronization because synchronization is not active”);
}
}
}
注册 SqlSession 到当前线程事务管理器的条件首先是当前环境中有事务，否则不注册，判断是否有事务的条件是 synchronizations 的 ThreadLocal 是否为空：
public static boolean isSynchronizationActive() {
return (synchronizations.get() != null);
}
每当我们开启一个事务，会调用 initSynchronization() 方法进行初始化 synchronizations，以激活当前线程事务管理器。
public static void initSynchronization() throws IllegalStateException {
if (isSynchronizationActive()) {
throw new IllegalStateException(“Cannot activate transaction synchronization – already active”);
}
logger.trace(“Initializing transaction synchronization”);
synchronizations.set(new LinkedHashSet<TransactionSynchronization>());
}
所以当前有事务时，会注册 SqlSession 到当前线程 ThreadLocal 中。
Mybatis 自己也实现了一个自定义的事务同步回调器 SqlSessionSynchronization，在注册 SqlSession 的同时，也会将 SqlSessionSynchronization 注册到当前线程事务管理器中，它的作用是根据事务的完成状态回调来处理线程资源，即当前如果有事务，那么当每次状态发生时就会回调事务同步器，具体细节可移步至 Spring 的 org.springframework.transaction.support 包。
回到 SqlSessionInterceptor 代理类的逻辑，发现判断会话是否需要提交要调用以下方法：
org.mybatis.spring.SqlSessionUtils#isSqlSessionTransactional：
public static boolean isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory) {
notNull(session, NO_SQL_SESSION_SPECIFIED);
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
return (holder != null) && (holder.getSqlSession() == session);
}
取决于当前 SqlSession 是否为空并且判断当前 SqlSession 是否与 ThreadLocal 中的 SqlSession 相等，前面也分析了，如果当前没有事务，SqlSession 是不会保存到事务同步管理器的，即没有事务，会话提交。
org.mybatis.spring.SqlSessionUtils#closeSqlSession：
public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {
notNull(session, NO_SQL_SESSION_SPECIFIED);
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
if ((holder != null) && (holder.getSqlSession() == session)) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“Releasing transactional SqlSession [” + session + “]”);
}
holder.released();
} else {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(“Closing non transactional SqlSession [” + session + “]”);
}
session.close();
}
}
方法无论执行结果如何都需要执行关闭会话逻辑，这里的判断也是判断当前是否有事务，如果 SqlSession 在事务当中，则减少引用次数，没有真实关闭会话。如果当前会话不存在事务，则直接关闭会话。
写在最后
虽说钟同学问了我一个 Mybatis 的问题，我却中了 Spring 的圈套，猛然发现整个事务链路都处在 Spring 的管控当中，这里涉及到了 Spring 的自定义事务的一些机制，其中当前线程事务管理器是整个事务的核心与中轴，当前有事务时，会初始化当前线程事务管理器的 synchronizations，即激活了当前线程同步管理器，当 Mybatis 访问数据库会首先从当前线程事务管理器获取 SqlSession，如果不存在就会创建一个会话，接着注册会话到当前线程事务管理器中，如果当前有事务，则会话不关闭也不 commit，Mybatis 还自定义了一个 TransactionSynchronization，用于事务每次状态发生时回调处理。
钟同学，this is for you！