Mybatis 原始碼分析（9）—— 事物管理
Mybatis 提供了事物的頂層介面：
public interface Transaction {
/**
* Retrieve inner database connection
* @return DataBase connection
* @throws SQLException
*/
Connection getConnection() throws SQLException;
/**
* Commit inner database connection.
* @throws SQLException
*/
void 還有一個事物工廠：
public interface TransactionFactory 對於這兩個介面我們一般是不直接操作的，但是它的影響是實實在在的。畢竟作為一個 ORM 框架，事物的管理是少不了的。它的實現大致可以分為兩類，非 Spring 相關的事物和基於 Spring 管理的事物。
非 Spring 相關
關於 JdbcTransaction 和 ManagedTransaction 這兩個實現就不多說了，實際上 getConnection 和 close 方法都是直接操作的 Connection。ManagedTransaction 的提交和回滾是個空的實現，交給容器了。
Mybatis對外提供的統一介面是SqlSession，通常情況下我們可以這樣使用：
public void doSomethingWithTemplate(){
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
try {
sqlSession = sqlSessionFactory.openSession();
doSomething();
sqlSession.commit();
} catch (Exception e) {
e.printStackTrace();
sqlSession.rollback();
} finally {
if (sqlSession != null) {
sqlSession.close();
}
}
}DefaultSqlSession 持有 Executor，將事物相關的操作做了簡單的封裝，Executor 又在此基礎上加入了一級快取等相關操作，如 commit 方法：
public void commit(boolean required) throws SQLException {
if (closed) throw new ExecutorException("Cannot commit, transaction is already closed");
clearLocalCache();
flushStatements();
if (required) {
transaction.commit();
}
}最終都呼叫了Mybatis提供的事物介面相關方法，以 JdbcTransaction 為例：
public void commit() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}這個提交就是判斷連線不為 null，而且不是自動提交的事物，那麼就呼叫 JDBC 連線的 commit 方法，回滾也是類似。
結合 Spring
在mybatis-spring中，提供了一個實現：
public class SpringManagedTransactionFactory implements TransactionFactory {
public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
return new SpringManagedTransaction(dataSource);
}
public Transaction newTransaction(Connection conn) {
throw new UnsupportedOperationException("New Spring transactions require a DataSource");
}
public void setProperties(Properties props) {
// not needed in this version
}
}在SqlSessionFactoryBean 中的 buildSqlSessionFactory 方法中指定了事物工廠為 SpringManagedTransactionFactory，然後將其放到 Environment 例項中：
if (this.transactionFactory == null) {
this.transactionFactory = new SpringManagedTransactionFactory();
}
Environment environment = new Environment(this.environment, this.transactionFactory, this.dataSource);
configuration.setEnvironment(environment);
//......
return this.sqlSessionFactoryBuilder.build(configuration);最後返回了sqlSessionFactoryBuilder 的 build 方法構建的 SqlSessionFactory：
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}DefaultSqlSessionFactory#openSessionFromDataSource：
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);
} 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();
}
}這時候 DataSource 是 Spring 管理的，事物是 SpringManagedTransaction。連線是找 Spring 要的，跟蹤一下發現事物由 Spring 直接處理了。
管理與操作
不管有沒有 Spring，Mybatis 都要作為一個獨立的 ORM 框架存在，所以事物管理是免不了的。Mybatis 定義了 Transaction 介面，對外提供的 SqlSession 間接操作了事物相關的介面。底層可以有不同的實現，處理起來更靈活。
JdbcTransaction 中的實現就是直接操作 JDBC Connection，ManagedTransaction 的實現就是為空，不做任何處理。但是作為和 Spring 結合使用的 SpringManagedTransaction，這個就有點複雜了。
都交給了 Spring，那麼它怎麼辦，Mybatis 底層也有依賴於事物的操作，如快取。
SqlSessionUtils 中的 SqlSessionSynchronization 內部類繼承了 TransactionSynchronizationAdapter，當 Spring 提交或者回滾時就會通過這個來回調。具體可以在事物提交前和提交後做一些操作，來彌補事物不在 Mybatis 這一方帶來的缺憾。
誰來管理，誰來操作
看一下 SpringManagedTransaction 是怎麼獲取連線的：
private void openConnection() throws SQLException {
this.connection = DataSourceUtils.getConnection(this.dataSource);
this.autoCommit = this.connection.getAutoCommit();
this.isConnectionTransactional = isConnectionTransactional(this.connection, this.dataSource);
if (this.logger.isDebugEnabled()) {
this.logger.debug(
"JDBC Connection ["
+ this.connection
+ "] will"
+ (this.isConnectionTransactional ? " " : " not ")
+ "be managed by Spring");
}
}再看下提交和回滾的實現：
public void commit() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Committing JDBC Connection [" + this.connection + "]");
}
this.connection.commit();
}
}
public void rollback() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Rolling back JDBC Connection [" + this.connection + "]");
}
this.connection.rollback();
}
}最後是否提交和回滾還得依賴一系列判斷，其中 isConnectionTransactional 是這樣判斷的：
public static boolean isConnectionTransactional(Connection con, DataSource dataSource) {
if (dataSource == null) {
return false;
}
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
return (conHolder != null && connectionEquals(conHolder, con));
}就是當前的JDBC連線是否是事務性的。如果是 Spring 管理的事物，這裡就返回 true。如果不是，還能留一手，在這裡補上一腳。
狀態的維護
既然事物是 Spring 管理，它如何管理呢？
就拿基於 AOP 的事物管理來說，切面都在 Service 層，考慮這樣一種情況，一個執行緒中可能同時存在多個事物：把一個基於 Servlet 的請求看作一個執行緒，呼叫了一個 Service ，而這個 Service 包含了多個相關 Mapper 的操作，這些操作必須存在於同一個事物中。
Mapper 方法的執行模板位於 SqlSessionTemplate:
private class SqlSessionInterceptor implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
final 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) {
Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
if (translated != null) {
unwrapped = translated;
}
}
throw unwrapped;
} finally {
closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
}
}
}這個和我們客戶端的方法執行模板還是有區別的，第一個需要考慮的問題是：這個方法往上層追溯，必然是位於 Spring 的事物執行模板之中。那麼這裡的 SqlSession 的獲取和關閉就不能隨隨便便，必須跟著“上面”走。
檢視原始碼可以看到，不論是 SqlSession 的獲取還是關閉，都是基於當前事物的狀態判斷，而不是直接在 ThreadLocal 中拿或者直接建立一個新的，體現在程式碼中就是：
SqlSessionHolder holder = (SqlSessionHolder) getResource(sessionFactory);
if (holder != null && holder.isSynchronizedWithTransaction()) {
if (holder.getExecutorType() != executorType) {
throw new TransientDataAccessResourceException("Cannot change the ExecutorType when there is an existing transaction");
}
holder.requested();
if (logger.isDebugEnabled()) {
logger.debug("Fetched SqlSession [" + holder.getSqlSession() + "] from current transaction");
}
return holder.getSqlSession();
}
if (logger.isDebugEnabled()) {
logger.debug("Creating a new SqlSession");
}
SqlSession session = sessionFactory.openSession(executorType);第一個就是 holder 不為 null， 第二是要求在同一個事物中，這些判斷依賴於 ResourceHolderSupport 和 TransactionSynchronizationManager，這是比執行緒更細粒度的控制，來自 Spring 管理的事物狀態。
試想一下，作為底層的框架，事物由 Spring 管理，Mybatis 如何知道事物是否開啟，如何判斷是否在同一個事物，而這些它不能不知道，畢竟 SqlSession 是它管理的，而 SqlSession 的生命週期又和事物息息相關。
上面舉了一個例子，如果多個 Mapper 存在於同一個事物中，那麼每次獲取的 SqlSession 必然是同一個，不會建立新的，這樣一級快取也會發揮出功效。
如果多個請求最終呼叫同一個 Mapper 呢？這時候 Mapper 持有的 SqlSession 是同一個(SqlSessionTemplate)，但實際在 invoke 方法中獲取 SqlSession 卻各不相同。
最後對 Mybatis 事物做一個總結：
