9、事务补充
当事务的传播级别为SUPPORTS时，如果当前有事务，则使用当前事务，如果当前没有事务，则以无事务方式执行
这里的无事务方式执行是指，Spring不会提交事务，而且MyBatis也不会执行commit。
除非设置数据库连接的auto-commit属性为true，否则不能写入数据
spring:
datasource:
auto-commit: true
1、propagation = Propagation.REQUIRED
在大多数情况下，我们使用默认隔离级别Propagation.REQUIRED，当propagation = Propagation.REQUIRED时，数据库连接由Spring事务管理器在DataSourceTransactionManager#doBegin中取得
doBegin会在org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction中被调用
org.springframework.jdbc.datasource.DataSourceTransactionManager#doBegin
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 由事务管理器从dataSource中获取连接
Connection newCon = obtainDataSource().getConnection();
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
if (con.getauto-commit()) {
txObject.setMustRestoreauto-commit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
// 当以有事务方式执行时，Spring会将数据库连接的auto-commit属性改为false
// 所以当开启新的事务或者说有事务方式执行时，auto-commit属性会无效
// 因为有事务，不论是当前创建新的事务，或者是继承自上一层的事务，都会是用的Spring获取的连接，auto-commit都会被改成false
con.setauto-commit(false);
}
prepareTransactionalConnection(con, definition);
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// Bind the connection holder to the thread.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
catch (Throwable ex) {
if (txObject.isNewConnectionHolder()) {
DataSourceUtils.releaseConnection(con, obtainDataSource());
txObject.setConnectionHolder(null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
以有事务方式执行时，事务的提交，也是由Spring执行
具体是在org.springframework.transaction.support.AbstractPlatformTransactionManager#processCommit中，具体不作分析了
还有一个问题。为什么有事务方式执行时，MyBatis不会提交事务？
相关逻辑在这里
org.mybatis.spring.SqlSessionTemplate.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);
// isSqlSessionTransactional会判断，当前执行SQL的会话sqlSession和在TransactionSynchronizationManager中和当前线程绑定的会话是否是同一个
// 如果是同一个，则说明事务由Spring管理，所以下面的sqlSession.commit(true);不会执行
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);
}
}
}
}
2、当事务的传播级别由REQUIRED改成SUPPORTS时
propagation = Propagation.SUPPORTS
在org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction中，由于propagation = Propagation.SUPPORTS，不会创建新的事务。
DataSourceTransactionManager#doBegin也不会被调用，所以auto-commit属性不会被修改，那么连接是在在哪里取的呢？
答案是在org.apache.ibatis.executor.SimpleExecutor#prepareStatement中由MyBatis自己搞定了
org.apache.ibatis.executor.SimpleExecutor#prepareStatement
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
org.apache.ibatis.executor.BaseExecutor#getConnection
protected Connection getConnection(Log statementLog) throws SQLException {
Connection connection = transaction.getConnection();
if (statementLog.isDebugEnabled()) {
return ConnectionLogger.newInstance(connection, statementLog, queryStack);
} else {
return connection;
}
}
org.apache.ibatis.transaction.jdbc.JdbcTransaction#getConnection
@Override
public Connection getConnection() throws SQLException {
if (connection == null) {
openConnection();
}
return connection;
}
传播级别为SUPPORTS时事务的提交有两种可能
a、auto-commit属性为false，事务不会提交，或者说connection不会commit（SqlSessionInterceptor的isSqlSessionTransactional此时仍然返回true）
b、auto-commit属性为true，事务由java.sql.Connection各个实现类自己在执行完SQL后自动提交了
3、不使用Spring事务，去掉@Transactionl注解
取数据库连接和使用propagation = Propagation.SUPPORTS时相同
事务的提交也有两种可能
a、auto-commit属性为false，事务由MyBatis提交（SqlSessionInterceptor的isSqlSessionTransactional此时返回false）
b、auto-commit属性为true，事务由java.sql.Connection各个实现类自己在执行完SQL后自动提交了
a和b两种情况都是执行一条SQL做一次commit。
在情况b中，SqlSessionInterceptor的isSqlSessionTransactional同样返回false，MyBatis为什么没有提交事务？
SqlSessionInterceptor中sqlSession.commit(true)，最终调用的是org.apache.ibatis.transaction.jdbc.JdbcTransaction#commit
org.apache.ibatis.transaction.jdbc.JdbcTransaction#commit
@Override
public void commit() throws SQLException {
// 当connection的auto-commit属性为true时，MyBatis不会自动commit
if (connection != null && !connection.getauto-commit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}
最后一个问题。propagation = Propagation.REQUIRED时，如果设置auto-commit属性为true，Spring会自动改成false，那么事务提交之后会将连接的自动提交属性改回来吗
答案是会
DataSourceTransactionManager.doBegin片段
if (con.getauto-commit()) {
// 这里将DataSourceTransactionObject的mustRestoreAutoCommit属性改成true，表示事务提交之后要重置connection的auto-commit属性为true
txObject.setMustRestoreauto-commit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}```
// 当以有事务方式执行时，Spring会将数据库连接的auto-commit属性改为false
// 所以当开启新的事务或者说有事务方式执行时，auto-commit属性会无效
// 因为有事务，不论是当前创建新的事务，或者是继承自上一层的事务，都会是用的Spring获取的连接，auto-commit都会被改成false
con.setauto-commit(false);
}
具体调用路径是
org.springframework.transaction.support.AbstractPlatformTransactionManager#processCommit
org.springframework.transaction.support.AbstractPlatformTransactionManager#cleanupAfterCompletion
org.springframework.jdbc.datasource.DataSourceTransactionManager#doCleanupAfterCompletion
protected void doCleanupAfterCompletion(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// Remove the connection holder from the thread, if exposed.
if (txObject.isNewConnectionHolder()) {
TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
// Reset connection.
Connection con = txObject.getConnectionHolder().getConnection();
try {
// 这里DataSourceTransactionObject的mustRestoreAutoCommit属性为true，修改连接auto-commit属性为true
if (txObject.isMustRestoreAutoCommit()) {
con.setAutoCommit(true);
}
DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
}
if (txObject.isNewConnectionHolder()) {
if (logger.isDebugEnabled()) {
logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
}
DataSourceUtils.releaseConnection(con, this.dataSource);
}
txObject.getConnectionHolder().clear();
}
