合肥 网站制作/seo专业培训课程

public Object invoke(MethodInvocation invocation) throws Throwable {Class<?> targetClass = (invocation.getThis() != null ?AopUtils.getTargetClass(invocation.getThis()) : null);// 调用父类的方法return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation){// 1. 获取事务属性TransactionAttributeSource tas = getTransactionAttributeSource();final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);// 2. 获取事务管理器final PlatformTransactionManager tm = determineTransactionManager(txAttr);// 3. 获取需要事务的方法名称：类目.方法名final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);// 4. 声明式事务if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {// 5. 获取该方法上事务的信息TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);Object retVal = null;try {// 6. 目标方法执行，它是一个拦截器链retVal = invocation.proceedWithInvocation();}catch (Throwable ex) {// 7. 事务回滚completeTransactionAfterThrowing(txInfo, ex);throw ex;}finally {// 8. 清除事务信息cleanupTransactionInfo(txInfo);}// 9. 事务提交commitTransactionAfterReturning(txInfo);return retVal;}else {// 10. 编程式事务，流程和声明式事务一致}
}

protected PlatformTransactionManager determineTransactionManager(TransactionAttribute txAttr) {if (txAttr == null || this.beanFactory == null) {return getTransactionManager();}// 事务管理器名称String qualifier = txAttr.getQualifier();if (StringUtils.hasText(qualifier)) {return determineQualifiedTransactionManager(this.beanFactory, qualifier);}else if (StringUtils.hasText(this.transactionManagerBeanName)) {return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);}else {// 默认事务管理器PlatformTransactionManager defaultTransactionManager = getTransactionManager();defaultTransactionManager = this.beanFactory.getBean(PlatformTransactionManager.class);// .....return defaultTransactionManager;}
}

TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

protected TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm,TransactionAttribute txAttr, final String joinpointIdentification) {// 设置事务的名称，为方法全限定名joinpointIdentificationif (txAttr != null && txAttr.getName() == null) {txAttr = new DelegatingTransactionAttribute(txAttr) {public String getName() {return joinpointIdentification;}};}TransactionStatus status = null;if (txAttr != null) {if (tm != null) {// 获取事务status = tm.getTransaction(txAttr);}}// 创建事务信息return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

public final TransactionStatus getTransaction(TransactionDefinition definition){// 获取事务Object transaction = doGetTransaction();// ...// 如果已经存在事务了，则处理事务的传播方式，如挂起存在的事务，新建事务等if (isExistingTransaction(transaction)) {return handleExistingTransaction(definition, transaction, debugEnabled);}// .....// 如果不存在事务，且事务的传播方式为 mandatory, 则抛出异常if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {throw new IllegalTransactionStateException("....");}else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {SuspendedResourcesHolder suspendedResources = suspend(null);// 如果事务的传播方式为 requested, requestes_new,nested,则会新建一个事务try {boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);// 第三个参数为true表示新建事务DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);// 构造 transaction,包括隔离级别，timeout,如果是新连接，则绑定到当前线程doBegin(transaction, definition);// 同步新事务prepareSynchronization(status, definition);return status;}catch (RuntimeException | Error ex) {resume(null, suspendedResources);throw ex;}}else {boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);}
}

protected Object doGetTransaction() {DataSourceTransactionObject txObject = new DataSourceTransactionObject();//如果设置了允许嵌套事务，则开启保存点；只有嵌套事务才有保存点txObject.setSavepointAllowed(isNestedTransactionAllowed());// 根据 DataSource 获取连接，ConnectionHolder为一个数据库连接ConnectionHolder conHolder = TransactionSynchronizationManager.getResource(obtainDataSource());txObject.setConnectionHolder(conHolder, false);return txObject;
}

DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//definition事务属性
//transaction事务
//newTransaction是否事务新事务
//suspendedResources需要挂起的事务
protected DefaultTransactionStatus newTransactionStatus(TransactionDefinition definition, Object transaction, boolean newTransaction,boolean newSynchronization, boolean debug, Object suspendedResources) {boolean actualNewSynchronization = newSynchronization &&!TransactionSynchronizationManager.isSynchronizationActive();return new DefaultTransactionStatus(transaction, newTransaction, actualNewSynchronization,definition.isReadOnly(), debug, suspendedResources);
}

protected void doBegin(Object transaction, TransactionDefinition definition) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;// 数据库连接Connection con = null;//如果当前事务不存在数据库连接，或者，当前连接的事务同步设置为 true，则需要获取新的数据库连接if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {// 获取新连接Connection newCon = obtainDataSource().getConnection();// 事务绑定新连接txObject.setConnectionHolder(new ConnectionHolder(newCon), true);}txObject.getConnectionHolder().setSynchronizedWithTransaction(true);con = txObject.getConnectionHolder().getConnection();// 获取和设置隔离级别Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);txObject.setPreviousIsolationLevel(previousIsolationLevel);// 由 Spring 来控制提交方式if (con.getAutoCommit()) {txObject.setMustRestoreAutoCommit(true);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());}//其他代码......
}// ====获取隔离级别
public static Integer prepareConnectionForTransaction(Connection con, TransactionDefinition definition){// 设置只读标识if (definition != null && definition.isReadOnly()) {con.setReadOnly(true);//....}// 获取隔离级别Integer previousIsolationLevel = null;if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {// 从数据库连接获取隔离级别int currentIsolation = con.getTransactionIsolation();if (currentIsolation != definition.getIsolationLevel()) {previousIsolationLevel = currentIsolation;con.setTransactionIsolation(definition.getIsolationLevel());}}return previousIsolationLevel;
}

protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {if (status.isNewSynchronization()) {TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?definition.getIsolationLevel() : null);TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());TransactionSynchronizationManager.initSynchronization();}
}

if (isExistingTransaction(transaction)) {return handleExistingTransaction(definition, transaction, debugEnabled);
}

protected boolean isExistingTransaction(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
}

private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction){// 如果传播方式为 never, 则抛异常if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {throw new IllegalTransactionStateException("...");}// 如果传播方式为 not_supported, 则把当前存在的事务挂起if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {// 挂起当前事务Object suspendedResources = suspend(transaction);boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);}// 如果传播方式为 requires_new, 则挂起当前事务，新建一个新事务if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {// 挂起当前事务SuspendedResourcesHolder suspendedResources = suspend(transaction);// 如果还没有激活事务，则新建事务boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);// 设置数据库的隔离级别,timeout等doBegin(transaction, definition);prepareSynchronization(status, definition);return status;//....}// 如果传播方式为 nested，则新建事务，但是不会把存在的事务挂起，它是一个子事务if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {// 如果不支持嵌套事务，抛异常if (!isNestedTransactionAllowed()) {throw new NestedTransactionNotSupportedException("");}// 如果支持保存点，则创建保存点if (useSavepointForNestedTransaction()) {DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);// 创建保存点								 status.createAndHoldSavepoint();return status;}else {// 如果不支持保存点，则和 requires_new 是一样的boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);doBegin(transaction, definition);prepareSynchronization(status, definition);return status;}}// 如果传播方式为 supports和requiredboolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {if (TransactionSynchronizationManager.isSynchronizationActive()) {List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();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);}//.....
}
// 挂起事务doSuspend
protected Object doSuspend(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;// 把事务的连接置空txObject.setConnectionHolder(null);// 从当前线程中移除return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}

protected TransactionInfo prepareTransactionInfo(PlatformTransactionManager tm,TransactionAttribute txAttr, String joinpointIdentification,TransactionStatus status) {// 封装事务信息TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);if (txAttr != null) {// 设置事务状态txInfo.newTransactionStatus(status);}
}

protected void completeTransactionAfterThrowing(TransactionInfo txInfo, Throwable ex) {if (txInfo != null && txInfo.getTransactionStatus() != null) {// 判断异常是不是 RunntimeException 和 Errorif (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {// 回滚事务txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());// .........}else {// 如果是其他类型的异常，则正常提交txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());// .......}}
}//判断是否回滚的异常，当前可以通过rolbackFor属性来修改
public boolean rollbackOn(Throwable ex) {return (ex instanceof RuntimeException || ex instanceof Error);
}

 public final void rollback(TransactionStatus status) throws TransactionException {if (status.isCompleted()) {// 如果事务已完成，则回滚会抛异常throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");} else {DefaultTransactionStatus defStatus = (DefaultTransactionStatus)status;this.processRollback(defStatus);}}
​private void processRollback(DefaultTransactionStatus status) {try {try {this.triggerBeforeCompletion(status);// 如果有保存点，则回滚到保存点if (status.hasSavepoint()) {if (status.isDebug()) {this.logger.debug("Rolling back transaction to savepoint");}
​status.rollbackToHeldSavepoint();} else if (status.isNewTransaction()) {// 如果当前事务为独立的事务，则回滚if (status.isDebug()) {this.logger.debug("Initiating transaction rollback");}
​this.doRollback(status);} else if (status.hasTransaction()) {// 如果一个事务中又有事务，如 required,该事务可以看作一个事务链，//那么当其中的一个事务需要回滚的时候，并不是立马进行回滚，//而是只是设置回滚状态，到最后再统一回滚if (!status.isLocalRollbackOnly() && !this.isGlobalRollbackOnParticipationFailure()) {if (status.isDebug()) {this.logger.debug("Participating transaction failed - letting transaction originator decide on rollback");}} else {if (status.isDebug()) {this.logger.debug("Participating transaction failed - marking existing transaction as rollback-only");}// 只是设置回滚状态this.doSetRollbackOnly(status);}} else {this.logger.debug("Should roll back transaction but cannot - no transaction available");}} catch (RuntimeException var7) {this.triggerAfterCompletion(status, 2);throw var7;} catch (Error var8) {this.triggerAfterCompletion(status, 2);throw var8;}this.triggerAfterCompletion(status, 1);} finally {// 清空记录并恢复被挂起的事务this.cleanupAfterCompletion(status);}
​}
​

public void rollbackToHeldSavepoint() throws TransactionException {Object savepoint = getSavepoint();// 回滚到保存点getSavepointManager().rollbackToSavepoint(savepoint);// 释放保存点getSavepointManager().releaseSavepoint(savepoint);setSavepoint(null);
}
// 回滚到保存点
public void rollbackToSavepoint(Object savepoint) throws TransactionException {ConnectionHolder conHolder = getConnectionHolderForSavepoint();conHolder.getConnection().rollback((Savepoint) savepoint);conHolder.resetRollbackOnly();// ......}
// 释放保存点
public void releaseSavepoint(Object savepoint) throws TransactionException {ConnectionHolder conHolder = getConnectionHolderForSavepoint();conHolder.getConnection().releaseSavepoint((Savepoint) savepoint);
}

protected void doRollback(DefaultTransactionStatus status) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();Connection con = txObject.getConnectionHolder().getConnection();con.rollback();
}

private void cleanupAfterCompletion(DefaultTransactionStatus status) {// 设置完成状态status.setCompleted();if (status.isNewSynchronization()) {TransactionSynchronizationManager.clear();}if (status.isNewTransaction()) {// 清除事务信息doCleanupAfterCompletion(status.getTransaction());}if (status.getSuspendedResources() != null) {// 恢复被挂起的事务Object transaction = (status.hasTransaction() ? status.getTransaction() : null);resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());}
}

protected void doCleanupAfterCompletion(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;// 从当前线程中移除数据库连接if (txObject.isNewConnectionHolder()) {TransactionSynchronizationManager.unbindResource(obtainDataSource());}//重置数据库连接Connection con = txObject.getConnectionHolder().getConnection();if (txObject.isMustRestoreAutoCommit()) {con.setAutoCommit(true);}DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());// 如果是新连接，则释放连接if (txObject.isNewConnectionHolder()) {DataSourceUtils.releaseConnection(con, this.dataSource);}txObject.getConnectionHolder().clear();
}

protected final void resume(Object transaction, SuspendedResourcesHolder resourcesHolder){if (resourcesHolder != null) {Object suspendedResources = resourcesHolder.suspendedResources;if (suspendedResources != null) {doResume(transaction, suspendedResources);}List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;if (suspendedSynchronizations != null) {TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);doResumeSynchronization(suspendedSynchronizations);}}
}
// 恢复事务，把事务和当前线程绑定
protected void doResume(Object transaction, Object suspendedResources) {TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
}

 public final void commit(TransactionStatus status) throws TransactionException {// 如果事务已完成，则不能提交if (status.isCompleted()) {throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");} else {// 判断嵌套事务是否设置了回滚标识，如果嵌套事务设置了回滚标识，则整个事务链都不会提交DefaultTransactionStatus defStatus = (DefaultTransactionStatus)status;if (defStatus.isLocalRollbackOnly()) {if (defStatus.isDebug()) {this.logger.debug("Transactional code has requested rollback");}
​this.processRollback(defStatus);} else if (!this.shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {if (defStatus.isDebug()) {this.logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");}
​this.processRollback(defStatus);//需要注意此处，如果为嵌套事务，内部事务设置 setRollbackOnly 后，最外层事务会报错if (status.isNewTransaction() || this.isFailEarlyOnGlobalRollbackOnly()) {throw new UnexpectedRollbackException("Transaction rolled back because it has been marked as rollback-only");}} else {// 提交事务this.processCommit(defStatus);}}}

private void processCommit(DefaultTransactionStatus status) throws TransactionException {try {boolean beforeCompletionInvoked = false;
​try {this.prepareForCommit(status);this.triggerBeforeCommit(status);this.triggerBeforeCompletion(status);beforeCompletionInvoked = true;boolean globalRollbackOnly = false;if (status.isNewTransaction() || this.isFailEarlyOnGlobalRollbackOnly()) {globalRollbackOnly = status.isGlobalRollbackOnly();}
​if (status.hasSavepoint()) {if (status.isDebug()) {this.logger.debug("Releasing transaction savepoint");}
​status.releaseHeldSavepoint();} else if (status.isNewTransaction()) {if (status.isDebug()) {this.logger.debug("Initiating transaction commit");}
​this.doCommit(status);}
​if (globalRollbackOnly) {throw new UnexpectedRollbackException("Transaction silently rolled back because it has been marked as rollback-only");}} catch (UnexpectedRollbackException var19) {this.triggerAfterCompletion(status, 1);throw var19;} catch (TransactionException var20) {if (this.isRollbackOnCommitFailure()) {this.doRollbackOnCommitException(status, var20);} else {this.triggerAfterCompletion(status, 2);}
​throw var20;} catch (RuntimeException var21) {if (!beforeCompletionInvoked) {this.triggerBeforeCompletion(status);}
​this.doRollbackOnCommitException(status, var21);throw var21;} catch (Error var22) {if (!beforeCompletionInvoked) {this.triggerBeforeCompletion(status);}// 如果提交过程中出现异常，则还是会回滚this.doRollbackOnCommitException(status, var22);throw var22;}
​try {this.triggerAfterCommit(status);} finally {this.triggerAfterCompletion(status, 0);}} finally {this.cleanupAfterCompletion(status);}
​}// 数据库连接进行回滚protected void doCommit(DefaultTransactionStatus status) {DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();Connection con = txObject.getConnectionHolder().getConnection();if (status.isDebug()) {this.logger.debug("Committing JDBC transaction on Connection [" + con + "]");}
​try {con.commit();} catch (SQLException var5) {throw new TransactionSystemException("Could not commit JDBC transaction", var5);}}到这里，Spring 事务的获取，提交，回滚去分析完毕了。