创建事务信息流程图
传播机制图
AbstractPlatformTransactionManager的suspend挂起当前事务
有些传播机制需要挂起当前事务，比如NOT_SUPPORTED，REQUIRES_NEW。首先会清除所有线程相关的同步状态，如果当前事务存在的话，就进行一些属性的清除，比如清空连接持有器，清空线程私有变量的同步状态，最后把当前事务清除的属性保存到一个SuspendedResourcesHolder里，以便于恢复的时候设置会去。
@Nullable
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
try {
Object suspendedResources = null;
if (transaction != null) {
suspendedResources = doSuspend(transaction);//挂起的资源，连接持有器
}
String name = TransactionSynchronizationManager.getCurrentTransactionName();//当前事务名字
TransactionSynchronizationManager.setCurrentTransactionName(null);//取消绑定
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();//当前事务可读性
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();//当前事务隔离级别
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();//当前事务激活状态
TransactionSynchronizationManager.setActualTransactionActive(false);
return new SuspendedResourcesHolder(
suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
}
catch (RuntimeException | Error ex) {
// doSuspend failed - original transaction is still active...
doResumeSynchronization(suspendedSynchronizations);
throw ex;
}
}
else if (transaction != null) {
// Transaction active but no synchronization active.
Object suspendedResources = doSuspend(transaction);
return new SuspendedResourcesHolder(suspendedResources);
}
else {
// Neither transaction nor synchronization active.
return null;
}
DataSourceTransactionManager的doSuspend挂起资源
@Override
protected Object doSuspend(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
txObject.setConnectionHolder(null);//清空连接持有器
return TransactionSynchronizationManager.unbindResource(obtainDataSource());//解绑线程私有的资源
}
AbstractPlatformTransactionManager的SuspendedResourcesHolder构造方法
其实就是保存了挂起事务的信息啦。
private SuspendedResourcesHolder(
@Nullable Object suspendedResources, List<TransactionSynchronization> suspendedSynchronizations,
@Nullable String name, boolean readOnly, @Nullable Integer isolationLevel, boolean wasActive) {
this.suspendedResources = suspendedResources;//连接持有器
this.suspendedSynchronizations = suspendedSynchronizations;//同步状态
this.name = name;//方法名
this.readOnly = readOnly;//是否只读
this.isolationLevel = isolationLevel;//隔离级别，默认mysql是可重复度，oracle是提交读
this.wasActive = wasActive;//事务是否激活
}
AbstractPlatformTransactionManager的newTransactionStatus创建事务状态
这里有个参数很重要newTransaction，是否是新连接，比如当前事务不存在的情况下，肯定是true，但是如果存在，就有可能false，具体还是看传播机制。
protected DefaultTransactionStatus newTransactionStatus(
TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
//是否要新同步，只有要新同步且当前无同步激活事务
boolean actualNewSynchronization = newSynchronization &&
!TransactionSynchronizationManager.isSynchronizationActive();
return new DefaultTransactionStatus(
transaction, newTransaction, actualNewSynchronization,
definition.isReadOnly(), debug, suspendedResources);
}
DefaultTransactionStatus创建默认事务状态
其实就是做个记录，这次事务的状态。
public DefaultTransactionStatus(
@Nullable Object transaction, boolean newTransaction, boolean newSynchronization,
boolean readOnly, boolean debug, @Nullable Object suspendedResources) {
this.transaction = transaction;//新创建事务
this.newTransaction = newTransaction;//是否需要新事务
this.newSynchronization = newSynchronization;//是否要新同步
this.readOnly = readOnly;//是否只读
this.debug = debug;//是否要debug
this.suspendedResources = suspendedResources;//是否有挂起的连接资源
}
DataSourceTransactionManager的doBegin开启连接和事务
这里就是开启新连接的地方，如果当前事务没有连接资源了，就会去创建一个新的连接，然后设置连接属性，做一些事务的标记等，表示是一个新的事务了。
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
if (!txObject.hasConnectionHolder() ||//当前事务没有连接资源
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
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);//设置先前隔离级别
txObject.setReadOnly(definition.isReadOnly());//设置是否只读
if (con.getAutoCommit()) {
txObject.setMustRestoreAutoCommit(true);//设置需要回复自动提交
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);//关闭自动提交
}
//是否需要设置只读命令
prepareTransactionalConnection(con, definition);
txObject.getConnectionHolder().setTransactionActive(true);//标记激活事务
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
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);
}
}
AbstractDriverBasedDataSource的getConnection获取一个连接
其实就是设置用户名和密码，最终是调用JDBC来获取连接。
TransactionSynchronizationManager的bindResource绑定数据源和连接资源
这里就是数据源和连接资源的绑定。
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。
