Spring事务02事务管理器2AbstractPlatformTransactionManager
挑几个常见的实现类，Spring 事务管理重要的是 DataSourceTransactionManager 。
1 类解释
/** * 实现Spring标准事务工作流的抽象基类，
* 作为具体平台事务管理器的基础，如{@link org.springframework.transaction.jta.JtaTransactionManager}。
*
* 这个基类提供了以下的工作流程处理:
* 1 确定是否存在现有事务;
* 2 应用适当的传播行为;
* 3 如有需要，暂停及恢复交易;
* 4 在提交时检查仅回滚标志;
* 5 对回滚应用适当的修改(实际回滚或仅设置回滚);
* 6 触发已注册的同步回调(如果事务同步是活动的)。
*
* 子类必须为事务的特定状态实现特定的模板方法，例如:begin、suspend、resume、commit、rollback。
* 其中最重要的是抽象的，必须通过具体的实现来提供;
* 对于其余部分，则提供默认值，因此覆盖是可选的。
*
* 事务同步是注册在事务完成时调用的回调的通用机制。
* 这主要是内部使用的数据访问支持类JDBC, Hibernate, JPA，
* 当在JTA事务中运行时:它们注册在事务中打开的资源，以便在事务完成时关闭，
* 允许在事务中重用同一个Hibernate会话。
* 同样的机制也可以用于应用程序中的自定义同步需求。
*
* 这个类的状态是可序列化的，允许序列化事务策略和携带事务拦截器的代理。
* 如果子类希望它们的状态也是可序列化的，则由子类决定。
* 它们应该实现{@code java.io.Serializable}标记接口，
* 如果需要恢复任何瞬态状态，则可以使用私有的{@code readObject()}方法(根据Java序列化规则)。
*
* @see #setTransactionSynchronization
* @see TransactionSynchronizationManager
* @see org.springframework.transaction.jta.JtaTransactionManager
*/
public abstract class AbstractPlatformTransactionManager
implements PlatformTransactionManager, Serializable {}
2 方法解释
2.1 doGetTransaction() 返回当前事务状态的事务对象
getTransaction() -> doGetTransaction() 抽象方法，子类需要实现。
/** * This implementation handles propagation behavior.
* Delegates to {@code doGetTransaction}, {@code isExistingTransaction} and {@code doBegin}.
*
* 此实现处理传播行为。
* 委托给{@code doGetTransaction}、{@code isExistingTransaction}和{@code doBegin}。
*
* @see #doGetTransaction
* @see #isExistingTransaction
* @see #doBegin
*/
@Override
publicfinal TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {
// 返回当前事务状态的事务对象
Object transaction = doGetTransaction();
/** 省略其他代码 **/
// 检查给定的事务对象是否指示现有事务(即已启动的事务)。
isExistingTransaction(transaction);
/** 省略其他代码 **/
// 根据给定的事务定义使用语义开始一个新的事务
doBegin(transaction, definition);
/** 省略其他代码 **/
}
/**
* Return a transaction object for the current transaction state.
* <p>The returned object will usually be specific to the concrete transaction
* manager implementation, carrying corresponding transaction state in a
* modifiable fashion. This object will be passed into the other template
* methods (e.g. doBegin and doCommit), either directly or as part of a
* DefaultTransactionStatus instance.
* <p>The returned object should contain information about any existing
* transaction, that is, a transaction that has already started before the
* current {@code getTransaction} call on the transaction manager.
* Consequently, a {@code doGetTransaction} implementation will usually
* look for an existing transaction and store corresponding state in the
* returned transaction object.
*
* 返回当前事务状态的事务对象。
* <p>返回的对象通常特定于具体的事务管理器实现，以可修改的方式携带相应的事务状态。
* 该对象将被传递到其他模板方法中(如doBegin和doCommit)，
* 直接或作为DefaultTransactionStatus实例的一部分。
* <p>返回的对象应该包含任何现有事务的信息，
* 也就是说，在事务管理器上的当前{@code getTransaction}调用之前已经启动的事务。
* 因此，{@code doGetTransaction}实现通常会查找现有事务并在返回的事务对象中存储相应的状态。
*
* @return the current transaction object
* @throws org.springframework.transaction.CannotCreateTransactionException
* if transaction support is not available
* @throws TransactionException in case of lookup or system errors
* @see #doBegin
* @see #doCommit
* @see #doRollback
* @see DefaultTransactionStatus#getTransaction
*/
protectedabstract Object doGetTransaction() throws TransactionException;
/**
* Check if the given transaction object indicates an existing transaction
* (that is, a transaction which has already started).
* <p>The result will be evaluated according to the specified propagation
* behavior for the new transaction. An existing transaction might get
* suspended (in case of PROPAGATION_REQUIRES_NEW), or the new transaction
* might participate in the existing one (in case of PROPAGATION_REQUIRED).
* <p>The default implementation returns {@code false}, assuming that
* participating in existing transactions is generally not supported.
* Subclasses are of course encouraged to provide such support.
*
* 检查给定的事务对象是否指示现有事务(即已启动的事务)。
*
* 结果将根据新事务的指定传播行为进行评估。
* 现有事务可能被挂起(在PROPAGATION_REQUIRES_NEW的情况下)，
* 或者，新的事务可能参与现有的事务(在PROPAGATION_REQUIRED的情况下)。
*
* 默认实现返回{@code false}，
* 假设通常不支持参与现有事务。
* 当然，我们鼓励子类提供这样的支持。
*
* @param transaction transaction object returned by doGetTransaction
* @return if there is an existing transaction
* @throws TransactionException in case of system errors
* @see #doGetTransaction
*/
protectedbooleanisExistingTransaction(Object transaction) throws TransactionException {
returnfalse;
}
2.2 doBegin() 根据给定的事务定义使用语义开始一个新的事务
getTransaction() -> doBegin() 抽象方法，子类需要实现。
/** * 根据给定的事务定义使用语义开始一个新的事务。
* 不需要关心传播行为的应用，
* 因为这个抽象管理器已经处理过了。
*
* 当事务管理器决定实际启动一个新事务时，将调用此方法。
* 要么之前没有任何事务，要么之前的事务已被挂起。
*
* 一个特殊的情况是嵌套的事务没有保存点:
* 如果{@code使用avepointfornestedtransaction()}返回“false”，
* 必要时将调用此方法启动嵌套事务。
* 在这种情况下，将会有一个活动事务:
* 此方法的实现必须检测此情况并启动适当的嵌套事务。
*
* @param transaction transaction object returned by {@code doGetTransaction}
* @param definition a TransactionDefinition instance, describing propagation
* behavior, isolation level, read-only flag, timeout, and transaction name
* @throws TransactionException in case of creation or system errors
*/
protected abstract void doBegin(Object transaction, TransactionDefinition definition)
throws TransactionException;
2.3 doCommit() 执行给定事务的实际提交
commit() -> processCommit() -> doCommit()抽象方法，子类需要实现。
/** * This implementation of commit handles participating in existing
* transactions and programmatic rollback requests.
* Delegates to {@code isRollbackOnly}, {@code doCommit}
* and {@code rollback}.
*
* 提交的这个实现处理参与现有事务和程序性回滚请求。
* 委托给{@code isRollbackOnly}、{@code doCommit}和{@code rollback}。
*
* @see org.springframework.transaction.TransactionStatus#isRollbackOnly()
* @see #doCommit
* @see #rollback
*/
@Override
public final void commit(TransactionStatus status) throws TransactionException {
/** 其他省略代码 **/
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
processCommit(defStatus);
}
/**
* Process an actual commit.
* Rollback-only flags have already been checked and applied.
*
* 处理实际的提交。仅回滚标志已经被检查和应用。
*
* @param status object representing the transaction
* @throws TransactionException in case of commit failure
*/
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
/** 其他省略代码 **/
doCommit(status);
/** 其他省略代码 **/
}
/**
* Perform an actual commit of the given transaction.
* <p>An implementation does not need to check the "new transaction" flag
* or the rollback-only flag; this will already have been handled before.
* Usually, a straight commit will be performed on the transaction object
* contained in the passed-in status.
*
* 执行给定事务的实际提交。
*
* 实现不需要检查“新事务”标志或只回滚标志;
* 这在以前已经处理过了。
* 通常，直接提交将对包含在传入状态中的事务对象执行。
*
* @param status the status representation of the transaction
* @throws TransactionException in case of commit or system errors
* @see DefaultTransactionStatus#getTransaction
*/
protected abstract void doCommit(DefaultTransactionStatus status) throws TransactionException;
2.3 doRollback() 执行给定事务的实际回滚
rollback() -> processRollback() -> doRollback() 抽象方法，子类需要实现
/** * This implementation of rollback handles participating in existing
* transactions. Delegates to {@code doRollback} and {@code doSetRollbackOnly}.
*
* 此回滚实现处理参与现有事务。
* 委托给{@code doRollback}和{@code doSetRollbackOnly}。
*
* @see #doRollback
* @see #doSetRollbackOnly
*/
@Override
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");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
processRollback(defStatus, false);
}
/**
* Process an actual rollback.
* The completed flag has already been checked.
*
* 处理实际的回滚。
* 已完成的标志已被检查。
*
* @param status object representing the transaction
* @throws TransactionException in case of rollback failure
*/
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
/** 其他省略代码 **/
doRollback(status);
/** 其他省略代码 **/
}
/**
* Perform an actual rollback of the given transaction.
* <p>An implementation does not need to check the "new transaction" flag;
* this will already have been handled before. Usually, a straight rollback
* will be performed on the transaction object contained in the passed-in status.
*
* 执行给定事务的实际回滚。
*
* 实现不需要检查“新事务”标志;
* 这在以前已经处理过了。
* 通常，将对包含在传入状态中的事务对象执行直接回滚。
*
* @param status the status representation of the transaction
* @throws TransactionException in case of system errors
* @see DefaultTransactionStatus#getTransaction
*/
protected abstract void doRollback(DefaultTransactionStatus status) throws TransactionException;
2.4 doCleanupAfterCompletion() 事务完成后清理资源
/** * 完成后进行清理，必要时清除同步，并在完成后调用doCleanupAfterCompletion。
* @param status object representing the transaction
* @see #doCleanupAfterCompletion
*/
private void cleanupAfterCompletion(DefaultTransactionStatus status) {
status.setCompleted();
if (status.isNewSynchronization()) {
TransactionSynchronizationManager.clear();
}
if (status.isNewTransaction()) {
doCleanupAfterCompletion(status.getTransaction());
}
if (status.getSuspendedResources() != null) {
if (status.isDebug()) {
logger.debug("Resuming suspended transaction after completion of inner transaction");
}
Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
}
}
/**
* 事务完成后清理资源。
* 在执行{@code doCommit}和{@code doRollback}之后，对任何结果调用。
* 默认实现什么也不做。
* 不应该抛出任何异常，而只是对错误发出警告。
* @param transaction transaction object returned by {@code doGetTransaction}
*/
protected void doCleanupAfterCompletion(Object transaction) {
}
以上是 Spring事务02事务管理器2AbstractPlatformTransactionManager 的全部内容， 来源链接： utcz.com/z/513322.html
