694 lines
27 KiB
Markdown
694 lines
27 KiB
Markdown
# 精尽 MyBatis 源码解析 —— Spring 集成（四）之事务
|
||
|
||
# 1. 概述
|
||
|
||
本文我们就来看看，Spring 和 MyBatis 的**事务**是如何集成。需要胖友阅读的前置文章是：
|
||
|
||
- [《精尽 MyBatis 源码分析 —— 事务模块》](http://svip.iocoder.cn/MyBatis/transaction-package/)
|
||
- [《精尽 Spring 源码分析 —— Transaction 源码简单导读》](http://svip.iocoder.cn/Spring/transaction-simple-intro/) 需要胖友对 Spring Transaction 有源码级的了解，否则对该文章，会有点懵逼。
|
||
|
||
# 2. SpringManagedTransaction
|
||
|
||
`org.mybatis.spring.transaction.SpringManagedTransaction` ，实现 `org.apache.ibatis.transaction.Transaction` 接口，Spring 托管事务的 Transaction 实现类。
|
||
|
||
## 2.1 构造方法
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
/**
|
||
* DataSource 对象
|
||
*/
|
||
private final DataSource dataSource;
|
||
/**
|
||
* Connection 对象
|
||
*/
|
||
private Connection connection;
|
||
/**
|
||
* 当前连接是否处于事务中
|
||
*
|
||
* @see DataSourceUtils#isConnectionTransactional(Connection, DataSource)
|
||
*/
|
||
private boolean isConnectionTransactional;
|
||
/**
|
||
* 是否自动提交
|
||
*/
|
||
private boolean autoCommit;
|
||
|
||
public SpringManagedTransaction(DataSource dataSource) {
|
||
notNull(dataSource, "No DataSource specified");
|
||
this.dataSource = dataSource;
|
||
}
|
||
```
|
||
|
||
## 2.2 getConnection
|
||
|
||
`#getConnection()` 方法，获得连接。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
@Override
|
||
public Connection getConnection() throws SQLException {
|
||
if (this.connection == null) {
|
||
// 如果连接不存在，获得连接
|
||
openConnection();
|
||
}
|
||
return this.connection;
|
||
}
|
||
```
|
||
|
||
- 如果 `connection` 为空，则调用 `#openConnection()` 方法，获得连接。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
/**
|
||
* Gets a connection from Spring transaction manager and discovers if this
|
||
* {@code Transaction} should manage connection or let it to Spring.
|
||
* <p>
|
||
* It also reads autocommit setting because when using Spring Transaction MyBatis
|
||
* thinks that autocommit is always false and will always call commit/rollback
|
||
* so we need to no-op that calls.
|
||
*/
|
||
private void openConnection() throws SQLException {
|
||
// 获得连接
|
||
this.connection = DataSourceUtils.getConnection(this.dataSource);
|
||
this.autoCommit = this.connection.getAutoCommit();
|
||
this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
|
||
|
||
LOGGER.debug(() ->
|
||
"JDBC Connection ["
|
||
+ this.connection
|
||
+ "] will"
|
||
+ (this.isConnectionTransactional ? " " : " not ")
|
||
+ "be managed by Spring");
|
||
}
|
||
```
|
||
|
||
- 比较有趣的是，此处获取连接，不是通过 `DataSource#getConnection()` 方法，而是通过 `org.springframework.jdbc.datasource.DataSourceUtils#getConnection(DataSource dataSource)` 方法，获得 Connection 对象。而实际上，基于 Spring Transaction 体系，如果此处正在**事务中**时，已经有和当前线程绑定的 Connection 对象，就是存储在 ThreadLocal 中。
|
||
|
||
## 2.3 commit
|
||
|
||
`#commit()` 方法，提交事务。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
@Override
|
||
public void commit() throws SQLException {
|
||
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
|
||
LOGGER.debug(() -> "Committing JDBC Connection [" + this.connection + "]");
|
||
this.connection.commit();
|
||
}
|
||
}
|
||
```
|
||
|
||
## 2.4 rollback
|
||
|
||
`#rollback()` 方法，回滚事务。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
@Override
|
||
public void rollback() throws SQLException {
|
||
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
|
||
LOGGER.debug(() -> "Rolling back JDBC Connection [" + this.connection + "]");
|
||
this.connection.rollback();
|
||
}
|
||
}
|
||
```
|
||
|
||
## 2.5 close
|
||
|
||
`#close()` 方法，释放连接。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
@Override
|
||
public void close() throws SQLException {
|
||
DataSourceUtils.releaseConnection(this.connection, this.dataSource);
|
||
}
|
||
```
|
||
|
||
- 比较有趣的是，此处获取连接，不是通过 `Connection#close()` 方法，而是通过 `org.springframework.jdbc.datasource.DataSourceUtils#releaseConnection(Connection connection,DataSource dataSource)` 方法，“释放”连接。但是，具体会不会关闭连接，根据当前线程绑定的 Connection 对象，是不是传入的 `connection` 参数。
|
||
|
||
## 2.6 getTimeout
|
||
|
||
```
|
||
// SpringManagedTransaction.java
|
||
|
||
@Override
|
||
public Integer getTimeout() throws SQLException {
|
||
ConnectionHolder holder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
|
||
if (holder != null && holder.hasTimeout()) {
|
||
return holder.getTimeToLiveInSeconds();
|
||
}
|
||
return null;
|
||
}
|
||
```
|
||
|
||
# 3. SpringManagedTransactionFactory
|
||
|
||
`org.mybatis.spring.transaction.SpringManagedTransactionFactory` ，实现 TransactionFactory 接口，SpringManagedTransaction 的工厂实现类。代码如下：
|
||
|
||
```
|
||
// SpringManagedTransactionFactory.java
|
||
|
||
public class SpringManagedTransactionFactory implements TransactionFactory {
|
||
|
||
@Override
|
||
public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
|
||
// 创建 SpringManagedTransaction 对象
|
||
return new SpringManagedTransaction(dataSource);
|
||
}
|
||
|
||
@Override
|
||
public Transaction newTransaction(Connection conn) {
|
||
// 抛出异常，因为 Spring 事务，需要一个 DataSource 对象
|
||
throw new UnsupportedOperationException("New Spring transactions require a DataSource");
|
||
}
|
||
|
||
@Override
|
||
public void setProperties(Properties props) {
|
||
// not needed in this version
|
||
}
|
||
|
||
}
|
||
```
|
||
|
||
# 4. SqlSessionHolder
|
||
|
||
`org.mybatis.spring.SqlSessionHolder` ，继承 `org.springframework.transaction.support.ResourceHolderSupport` 抽象类，SqlSession 持有器，用于保存当前 SqlSession 对象，保存到 `org.springframework.transaction.support.TransactionSynchronizationManager` 中。代码如下：
|
||
|
||
```
|
||
// SqlSessionHolder.java
|
||
|
||
/**
|
||
* Used to keep current {@code SqlSession} in {@code TransactionSynchronizationManager}.
|
||
*
|
||
* The {@code SqlSessionFactory} that created that {@code SqlSession} is used as a key.
|
||
* {@code ExecutorType} is also kept to be able to check if the user is trying to change it
|
||
* during a TX (that is not allowed) and throw a Exception in that case.
|
||
*
|
||
* SqlSession 持有器，用于保存当前 SqlSession 对象，保存到 TransactionSynchronizationManager 中
|
||
*
|
||
* @author Hunter Presnall
|
||
* @author Eduardo Macarron
|
||
*/
|
||
public final class SqlSessionHolder extends ResourceHolderSupport {
|
||
|
||
/**
|
||
* SqlSession 对象
|
||
*/
|
||
private final SqlSession sqlSession;
|
||
/**
|
||
* 执行器类型
|
||
*/
|
||
private final ExecutorType executorType;
|
||
/**
|
||
* PersistenceExceptionTranslator 对象
|
||
*/
|
||
private final PersistenceExceptionTranslator exceptionTranslator;
|
||
|
||
/**
|
||
* Creates a new holder instance.
|
||
*
|
||
* @param sqlSession the {@code SqlSession} has to be hold.
|
||
* @param executorType the {@code ExecutorType} has to be hold.
|
||
* @param exceptionTranslator the {@code PersistenceExceptionTranslator} has to be hold.
|
||
*/
|
||
public SqlSessionHolder(SqlSession sqlSession,
|
||
ExecutorType executorType,
|
||
PersistenceExceptionTranslator exceptionTranslator) {
|
||
notNull(sqlSession, "SqlSession must not be null");
|
||
notNull(executorType, "ExecutorType must not be null");
|
||
|
||
this.sqlSession = sqlSession;
|
||
this.executorType = executorType;
|
||
this.exceptionTranslator = exceptionTranslator;
|
||
}
|
||
|
||
// ... 省略 getting 方法
|
||
|
||
}
|
||
```
|
||
|
||
- 当存储到 TransactionSynchronizationManager 中时，使用的 KEY 为创建该 SqlSession 对象的 SqlSessionFactory 对象。详细解析，见 `SqlSessionUtils#registerSessionHolder(...)` 方法。
|
||
|
||
# 5. SqlSessionUtils
|
||
|
||
`org.mybatis.spring.SqlSessionUtils` ，SqlSession 工具类。它负责处理 MyBatis SqlSession 的生命周期。它可以从 Spring TransactionSynchronizationManager 中，注册和获得对应的 SqlSession 对象。同时，它也支持当前不处于事务的情况下。
|
||
|
||
😈 当然，这个描述看起来，有点绕。所以，我们直接干起代码。
|
||
|
||
## 5.1 构造方法
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
private static final String NO_EXECUTOR_TYPE_SPECIFIED = "No ExecutorType specified";
|
||
private static final String NO_SQL_SESSION_FACTORY_SPECIFIED = "No SqlSessionFactory specified";
|
||
private static final String NO_SQL_SESSION_SPECIFIED = "No SqlSession specified";
|
||
|
||
/**
|
||
* This class can't be instantiated, exposes static utility methods only.
|
||
*/
|
||
private SqlSessionUtils() {
|
||
// do nothing
|
||
}
|
||
```
|
||
|
||
- 空的，直接跳过。
|
||
|
||
## 5.2 getSqlSession
|
||
|
||
`#getSqlSession(SqlSessionFactory sessionFactory, ...)` 方法，获得 SqlSession 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
/**
|
||
* Creates a new MyBatis {@code SqlSession} from the {@code SqlSessionFactory}
|
||
* provided as a parameter and using its {@code DataSource} and {@code ExecutorType}
|
||
*
|
||
* @param sessionFactory a MyBatis {@code SqlSessionFactory} to create new sessions
|
||
* @return a MyBatis {@code SqlSession}
|
||
* @throws TransientDataAccessResourceException if a transaction is active and the
|
||
* {@code SqlSessionFactory} is not using a {@code SpringManagedTransactionFactory}
|
||
*/
|
||
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory) {
|
||
// 获得执行器类型
|
||
ExecutorType executorType = sessionFactory.getConfiguration().getDefaultExecutorType();
|
||
// 获得 SqlSession 对象
|
||
return getSqlSession(sessionFactory, executorType, null);
|
||
}
|
||
|
||
/**
|
||
* Gets an SqlSession from Spring Transaction Manager or creates a new one if needed.
|
||
* Tries to get a SqlSession out of current transaction. If there is not any, it creates a new one.
|
||
* Then, it synchronizes the SqlSession with the transaction if Spring TX is active and
|
||
* <code>SpringManagedTransactionFactory</code> is configured as a transaction manager.
|
||
*
|
||
* @param sessionFactory a MyBatis {@code SqlSessionFactory} to create new sessions
|
||
* @param executorType The executor type of the SqlSession to create
|
||
* @param exceptionTranslator Optional. Translates SqlSession.commit() exceptions to Spring exceptions.
|
||
* @return an SqlSession managed by Spring Transaction Manager
|
||
* @throws TransientDataAccessResourceException if a transaction is active and the
|
||
* {@code SqlSessionFactory} is not using a {@code SpringManagedTransactionFactory}
|
||
* @see SpringManagedTransactionFactory
|
||
*/
|
||
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
|
||
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
|
||
notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
|
||
|
||
// <1> 获得 SqlSessionHolder 对象
|
||
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
|
||
|
||
// <2.1> 获得 SqlSession 对象
|
||
SqlSession session = sessionHolder(executorType, holder);
|
||
if (session != null) { // <2.2> 如果非空，直接返回
|
||
return session;
|
||
}
|
||
|
||
LOGGER.debug(() -> "Creating a new SqlSession");
|
||
// <3.1> 创建 SqlSession 对象
|
||
session = sessionFactory.openSession(executorType);
|
||
// <3.2> 注册到 TransactionSynchronizationManager 中
|
||
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
|
||
|
||
return session;
|
||
}
|
||
```
|
||
|
||
- 我们先看看每一步的作用，然后胖友在自己看下上面的英文注释，嘿嘿。
|
||
|
||
- `<1>` 处，调用 `TransactionSynchronizationManager#getResource(sessionFactory)` 方法，获得 SqlSessionHolder 对象。为什么可以获取到呢？答案在 `<3.2>` 中。关于 TransactionSynchronizationManager 类，如果不熟悉的胖友，真的真的真的，先去看懂 Spring Transaction 体系。
|
||
|
||
- `<2.1>` 处，调用 `#sessionHolder(ExecutorType executorType, SqlSessionHolder holder)` 方法，从 SqlSessionHolder 中，获得 SqlSession 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
private static SqlSession sessionHolder(ExecutorType executorType, SqlSessionHolder holder) {
|
||
SqlSession session = null;
|
||
if (holder != null && holder.isSynchronizedWithTransaction()) {
|
||
// 如果执行器类型发生了变更，抛出 TransientDataAccessResourceException 异常
|
||
if (holder.getExecutorType() != executorType) {
|
||
throw new TransientDataAccessResourceException("Cannot change the ExecutorType when there is an existing transaction");
|
||
}
|
||
|
||
// <1> 增加计数
|
||
holder.requested();
|
||
|
||
LOGGER.debug(() -> "Fetched SqlSession [" + holder.getSqlSession() + "] from current transaction");
|
||
// <2> 获得 SqlSession 对象
|
||
session = holder.getSqlSession();
|
||
}
|
||
return session;
|
||
}
|
||
```
|
||
|
||
- `<1>` 处，调用 `SqlSessionHolder#requested()` 方法，增加计数。注意，这个的计数，是用于关闭 SqlSession 时使用。详细解析，见 TODO 方法。
|
||
- `<2>` 处，调用 `SqlSessionHolder#getSqlSession()` 方法，获得 SqlSession 对象。
|
||
|
||
- `<2.2>` 处，如果非空，直接返回。
|
||
|
||
- `<3.1>` 处，调用 `SqlSessionFactory#openSession(executorType)` 方法，创建 SqlSession 对象。其中，使用的执行器类型，由传入的 `executorType` 方法参数所决定。
|
||
|
||
- `<3.2>` 处，调用 `#registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator, SqlSession session)` 方法，注册 SqlSession 对象，到 TransactionSynchronizationManager 中。代码如下：
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
/**
|
||
* Register session holder if synchronization is active (i.e. a Spring TX is active).
|
||
*
|
||
* Note: The DataSource used by the Environment should be synchronized with the
|
||
* transaction either through DataSourceTxMgr or another tx synchronization.
|
||
* Further assume that if an exception is thrown, whatever started the transaction will
|
||
* handle closing / rolling back the Connection associated with the SqlSession.
|
||
*
|
||
* @param sessionFactory sqlSessionFactory used for registration.
|
||
* @param executorType executorType used for registration.
|
||
* @param exceptionTranslator persistenceExceptionTranslator used for registration.
|
||
* @param session sqlSession used for registration.
|
||
*/
|
||
private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,
|
||
PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {
|
||
SqlSessionHolder holder;
|
||
if (TransactionSynchronizationManager.isSynchronizationActive()) {
|
||
Environment environment = sessionFactory.getConfiguration().getEnvironment();
|
||
|
||
// <1> 如果使用 Spring 事务管理器
|
||
if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {
|
||
LOGGER.debug(() -> "Registering transaction synchronization for SqlSession [" + session + "]");
|
||
|
||
// <1.1> 创建 SqlSessionHolder 对象
|
||
holder = new SqlSessionHolder(session, executorType, exceptionTranslator);
|
||
// <1.2> 绑定到 TransactionSynchronizationManager 中
|
||
TransactionSynchronizationManager.bindResource(sessionFactory, holder);
|
||
// <1.3> 创建 SqlSessionSynchronization 到 TransactionSynchronizationManager 中
|
||
TransactionSynchronizationManager.registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));
|
||
// <1.4> 设置同步
|
||
holder.setSynchronizedWithTransaction(true);
|
||
// <1.5> 增加计数
|
||
holder.requested();
|
||
// <2> 如果非 Spring 事务管理器，抛出 TransientDataAccessResourceException 异常
|
||
} else {
|
||
TransactionSynchronizationManager.getResource(environment.getDataSource());
|
||
throw new TransientDataAccessResourceException(
|
||
"SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization");
|
||
}
|
||
} else {
|
||
LOGGER.debug(() -> "SqlSession [" + session + "] was not registered for synchronization because synchronization is not active");
|
||
}
|
||
}
|
||
```
|
||
|
||
- `<2>` 处，如果非 Spring 事务管理器，抛出 TransientDataAccessResourceException 异常。
|
||
|
||
- ```
|
||
<1>
|
||
```
|
||
|
||
|
||
|
||
处，如果使用 Spring 事务管理器(
|
||
|
||
|
||
|
||
SpringManagedTransactionFactory
|
||
|
||
|
||
|
||
)，则进行注册。
|
||
|
||
- `<1.1>` 处，将 `sqlSession` 封装成 SqlSessionHolder 对象。
|
||
- `<1.2>` 处，调用 `TransactionSynchronizationManager#bindResource(sessionFactory, holder)` 方法，绑定 `holder` 到 TransactionSynchronizationManager 中。**注意**，此时的 KEY 是 `sessionFactory` ，就创建 `sqlSession` 的 SqlSessionFactory 对象。
|
||
- `<1.3>` 处，创建 SqlSessionSynchronization 到 TransactionSynchronizationManager 中。详细解析，见 [「6. SqlSessionSynchronization」](https://svip.iocoder.cn/MyBatis/Spring-Integration-4/#) 。
|
||
- `<1.4>` 处，设置同步。
|
||
- `<1.5>` 处，调用 `SqlSessionHolder#requested()` 方法，增加计数。
|
||
|
||
## 5.3 isSqlSessionTransactional
|
||
|
||
`#isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory)` 方法，判断传入的 SqlSession 参数，是否在 Spring 事务中。代码如下：
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
/**
|
||
* Returns if the {@code SqlSession} passed as an argument is being managed by Spring
|
||
*
|
||
* @param session a MyBatis SqlSession to check
|
||
* @param sessionFactory the SqlSessionFactory which the SqlSession was built with
|
||
* @return true if session is transactional, otherwise false
|
||
*/
|
||
public static boolean isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory) {
|
||
notNull(session, NO_SQL_SESSION_SPECIFIED);
|
||
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
|
||
|
||
// 从 TransactionSynchronizationManager 中，获得 SqlSessionHolder 对象
|
||
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
|
||
// 如果相等，说明在 Spring 托管的事务中
|
||
return (holder != null) && (holder.getSqlSession() == session);
|
||
}
|
||
```
|
||
|
||
- 代码比较简单，直接看注释。
|
||
|
||
## 5.4 closeSqlSession
|
||
|
||
`#closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory)` 方法，关闭 SqlSession 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionUtils.java
|
||
|
||
/**
|
||
* Checks if {@code SqlSession} passed as an argument is managed by Spring {@code TransactionSynchronizationManager}
|
||
* If it is not, it closes it, otherwise it just updates the reference counter and
|
||
* lets Spring call the close callback when the managed transaction ends
|
||
*
|
||
* @param session a target SqlSession
|
||
* @param sessionFactory a factory of SqlSession
|
||
*/
|
||
public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {
|
||
notNull(session, NO_SQL_SESSION_SPECIFIED);
|
||
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
|
||
|
||
// <1> 从 TransactionSynchronizationManager 中，获得 SqlSessionHolder 对象
|
||
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
|
||
|
||
// <2.1> 如果相等，说明在 Spring 托管的事务中，则释放 holder 计数
|
||
if ((holder != null) && (holder.getSqlSession() == session)) {
|
||
LOGGER.debug(() -> "Releasing transactional SqlSession [" + session + "]");
|
||
holder.released();
|
||
// <2.2> 如果不相等，说明不在 Spring 托管的事务中，直接关闭 SqlSession 对象
|
||
} else {
|
||
LOGGER.debug(() -> "Closing non transactional SqlSession [" + session + "]");
|
||
session.close();
|
||
}
|
||
}
|
||
```
|
||
|
||
- `<1>` 处，从 TransactionSynchronizationManager 中，获得 SqlSessionHolder 对象。
|
||
- `<2.1>` 处，如果相等，说明在 Spring 托管的事务中，则释放 `holder` 计数。那有什么用呢？具体原因，见 [「6. SqlSessionSynchronization」](https://svip.iocoder.cn/MyBatis/Spring-Integration-4/#) 。
|
||
- `<2.2>` 处，如果不相等，说明不在 Spring 托管的事务中，直接关闭 SqlSession 对象。
|
||
|
||
# 6. SqlSessionSynchronization
|
||
|
||
SqlSessionSynchronization ，是 SqlSessionUtils 的内部类，继承 TransactionSynchronizationAdapter 抽象类，SqlSession 的 同步器，基于 Spring Transaction 体系。
|
||
|
||
```
|
||
/**
|
||
* Callback for cleaning up resources. It cleans TransactionSynchronizationManager and
|
||
* also commits and closes the {@code SqlSession}.
|
||
* It assumes that {@code Connection} life cycle will be managed by
|
||
* {@code DataSourceTransactionManager} or {@code JtaTransactionManager}
|
||
*/
|
||
```
|
||
|
||
## 6.1 构造方法
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
/**
|
||
* SqlSessionHolder 对象
|
||
*/
|
||
private final SqlSessionHolder holder;
|
||
/**
|
||
* SqlSessionFactory 对象
|
||
*/
|
||
private final SqlSessionFactory sessionFactory;
|
||
/**
|
||
* 是否开启
|
||
*/
|
||
private boolean holderActive = true;
|
||
|
||
public SqlSessionSynchronization(SqlSessionHolder holder, SqlSessionFactory sessionFactory) {
|
||
notNull(holder, "Parameter 'holder' must be not null");
|
||
notNull(sessionFactory, "Parameter 'sessionFactory' must be not null");
|
||
|
||
this.holder = holder;
|
||
this.sessionFactory = sessionFactory;
|
||
}
|
||
```
|
||
|
||
## 6.2 getOrder
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
@Override
|
||
public int getOrder() {
|
||
// order right before any Connection synchronization
|
||
return DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER - 1;
|
||
}
|
||
```
|
||
|
||
## 6.3 suspend
|
||
|
||
`#suspend()` 方法，当事务挂起时，取消当前线程的绑定的 SqlSessionHolder 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
@Override
|
||
public void suspend() {
|
||
if (this.holderActive) {
|
||
LOGGER.debug(() -> "Transaction synchronization suspending SqlSession [" + this.holder.getSqlSession() + "]");
|
||
TransactionSynchronizationManager.unbindResource(this.sessionFactory);
|
||
}
|
||
}
|
||
```
|
||
|
||
## 6.4 resume
|
||
|
||
`#resume()` 方法，当事务恢复时，重新绑定当前线程的 SqlSessionHolder 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
public void resume() {
|
||
if (this.holderActive) {
|
||
LOGGER.debug(() -> "Transaction synchronization resuming SqlSession [" + this.holder.getSqlSession() + "]");
|
||
TransactionSynchronizationManager.bindResource(this.sessionFactory, this.holder);
|
||
}
|
||
}
|
||
```
|
||
|
||
- 因为，当前 SqlSessionSynchronization 对象中，有 `holder` 对象，所以可以直接恢复。
|
||
|
||
## 6.5 beforeCommit
|
||
|
||
`#beforeCommit(boolean readOnly)` 方法，在事务提交之前，调用 `SqlSession#commit()` 方法，提交事务。虽然说，Spring 自身也会调用 `Connection#commit()` 方法，进行事务的提交。但是，`SqlSession#commit()` 方法中，不仅仅有事务的提交，还有提交批量操作，刷新本地缓存等等。代码如下：
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
@Override
|
||
public void beforeCommit(boolean readOnly) {
|
||
// Connection commit or rollback will be handled by ConnectionSynchronization or
|
||
// DataSourceTransactionManager.
|
||
// But, do cleanup the SqlSession / Executor, including flushing BATCH statements so
|
||
// they are actually executed.
|
||
// SpringManagedTransaction will no-op the commit over the jdbc connection
|
||
// TODO This updates 2nd level caches but the tx may be rolledback later on!
|
||
if (TransactionSynchronizationManager.isActualTransactionActive()) {
|
||
try {
|
||
LOGGER.debug(() -> "Transaction synchronization committing SqlSession [" + this.holder.getSqlSession() + "]");
|
||
// 提交事务
|
||
this.holder.getSqlSession().commit();
|
||
} catch (PersistenceException p) {
|
||
// 如果发生异常，则进行转换，并抛出异常
|
||
if (this.holder.getPersistenceExceptionTranslator() != null) {
|
||
DataAccessException translated = this.holder
|
||
.getPersistenceExceptionTranslator()
|
||
.translateExceptionIfPossible(p);
|
||
throw translated;
|
||
}
|
||
throw p;
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
- 耐心的看看英文注释，更有助于理解该方法。
|
||
|
||
## 6.6 beforeCompletion
|
||
|
||
> 老艿艿：TransactionSynchronization 的事务提交的执行顺序是：beforeCommit => beforeCompletion => 提交操作 => afterCompletion => afterCommit 。
|
||
|
||
`#beforeCompletion()` 方法，提交事务完成之前，关闭 SqlSession 对象。代码如下：
|
||
|
||
```
|
||
// SqlSessionSynchronization.java
|
||
|
||
@Override
|
||
public void beforeCompletion() {
|
||
// Issue #18 Close SqlSession and deregister it now
|
||
// because afterCompletion may be called from a different thread
|
||
if (!this.holder.isOpen()) {
|
||
LOGGER.debug(() -> "Transaction synchronization deregistering SqlSession [" + this.holder.getSqlSession() + "]");
|
||
// 取消当前线程的绑定的 SqlSessionHolder 对象
|
||
TransactionSynchronizationManager.unbindResource(sessionFactory);
|
||
// 标记无效
|
||
this.holderActive = false;
|
||
LOGGER.debug(() -> "Transaction synchronization closing SqlSession [" + this.holder.getSqlSession() + "]");
|
||
// 关闭 SqlSession 对象
|
||
this.holder.getSqlSession().close();
|
||
}
|
||
}
|
||
```
|
||
|
||
- 因为，beforeCompletion 方法是在 beforeCommit 之后执行，并且在 beforeCommit 已经提交了事务，所以此处可以放心关闭 SqlSession 对象了。
|
||
|
||
- 要执行关闭操作之前，需要先调用 `SqlSessionHolder#isOpen()` 方法来判断，是否处于开启状态。代码如下：
|
||
|
||
```
|
||
// ResourceHolderSupport.java
|
||
|
||
public boolean isOpen() {
|
||
return (this.referenceCount > 0);
|
||
}
|
||
```
|
||
|
||
- 这就是，我们前面看到的各种计数增减的作用。
|
||
|
||
## 6.7 afterCompletion
|
||
|
||
`#afterCompletion()` 方法，解决可能出现的**跨线程**的情况，简单理解下就好。代码如下：
|
||
|
||
```
|
||
// ResourceHolderSupport.java
|
||
|
||
@Override
|
||
public void afterCompletion(int status) {
|
||
if (this.holderActive) { // 处于有效状态
|
||
// afterCompletion may have been called from a different thread
|
||
// so avoid failing if there is nothing in this one
|
||
LOGGER.debug(() -> "Transaction synchronization deregistering SqlSession [" + this.holder.getSqlSession() + "]");
|
||
// 取消当前线程的绑定的 SqlSessionHolder 对象
|
||
TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory);
|
||
// 标记无效
|
||
this.holderActive = false;
|
||
LOGGER.debug(() -> "Transaction synchronization closing SqlSession [" + this.holder.getSqlSession() + "]");
|
||
// 关闭 SqlSession 对象
|
||
this.holder.getSqlSession().close();
|
||
}
|
||
this.holder.reset();
|
||
}
|
||
```
|
||
|
||
- 😈 貌似，官方没对这块做单元测试。
|
||
|
||
# 666. 彩蛋
|
||
|
||
越写越清晰，哈哈哈哈。
|
||
|
||
参考和推荐如下文章：
|
||
|
||
- fifadxj [《mybatis-spring事务处理机制分析》](https://my.oschina.net/fifadxj/blog/785621) 提供了序列图 |