六Spring事务--3事务组件类
六Spring事务--3事务组件类
6.2.3 事务组件类
6.2.3.1 AbstractBeanFactoryPointcutAdvisor--(advisor)
AbstractBeanFactoryPointcutAdvisor作为spring事务中的advisor类，主要包裹了advice（增强）和pointcut（切点）信息。
另外，实现了 BeanFactoryAware接口 的PointcutAdvisor抽象类，允许将任何 Advice 配置为BeanFactory中的bean，例如：TransactionInterceptor。
实现了BeanFactoryAware，会将BeanFactory对象设置到该对象里，然后就可以通过BeanFactory获取到相应的Advice bean。
作用：
advisor通过该类，指定advice的name，而不是特定的advice对象，避免过早实例化，只有当pointcut匹配时，才实例化该advice（匹配后，getAdvice时，根据adviceName从beanfactory中获取该advice对象——beanFactory.getBean）
public abstract class AbstractBeanFactoryPointcutAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {
//getter/setter方法
private String adviceBeanName;
//实现了BeanFactoryAware接口
private BeanFactory beanFactory;
private transient volatile Advice advice;
//对象锁，用synchronized（monitor）加锁，对this.advice进行安全操作
private transient volatile Object adviceMonitor = new Object();
//给advisor直接指定一个Advice实例bean
public void setAdvice(Advice advice) {
//加锁，设置this.advice
synchronized (this.adviceMonitor) {
this.advice = advice;
}
}
@Override
public Advice getAdvice() {
Advice advice = this.advice;
if (advice != null) {
return advice;
}
Assert.state(this.adviceBeanName != null, "'adviceBeanName' must be specified");
Assert.state(this.beanFactory != null, "BeanFactory must be set to resolve 'adviceBeanName'");
//如果bean factory中有该advice的单例，则直接获取
if (this.beanFactory.isSingleton(this.adviceBeanName)) {
//从beanFactory中获取
advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
this.advice = advice;
return advice;
}
//如果不是单例，则加上锁，然后再从bean factory中获取该实例
else {
synchronized (this.adviceMonitor) {
advice = this.advice;
if (advice == null) {
advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
this.advice = advice;
}
return advice;
}
}
}
}
6.2.3.1.1 BeanFactoryTransactionAttributeSourceAdvisor
由TransactionAttributeSource驱动的advisor切面，被用来包裹（添加）事务性方法的事务性增强advice。
public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {
//创建事务属性TransactionAttribute的source类，该source类用于找到事物属性
@Nullable
private TransactionAttributeSource transactionAttributeSource;
//advisor的切点
private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
@Override
@Nullable
protected TransactionAttributeSource getTransactionAttributeSource() {
return transactionAttributeSource;
}
};
//设置类过滤器
public void setClassFilter(ClassFilter classFilter) {
this.pointcut.setClassFilter(classFilter);
}
6.2.3.2 TransactionAttributeSourcePointcut--(pointcut)
如果底层TransactionAttributeSource具有给定method的属性attribute，则实现pointcut的内部类会match成功。
abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {
//设置类过滤器
protected TransactionAttributeSourcePointcut() {
setClassFilter(new TransactionAttributeSourceClassFilter());
}
//methodfilter的match的匹配逻辑
@Override
public boolean matches(Method method, Class<?> targetClass) {
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
//获取底层的TransactionAttributeSource，由子类实现该方法
@Nullable
protected abstract TransactionAttributeSource getTransactionAttributeSource();
//类过滤内部类
private class TransactionAttributeSourceClassFilter implements ClassFilter {
@Override
public boolean matches(Class<?> clazz) {
if (TransactionalProxy.class.isAssignableFrom(clazz) ||
PlatformTransactionManager.class.isAssignableFrom(clazz) ||
PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
return false;
}
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.isCandidateClass(clazz));
}
}
}
6.2.3.3 TransactionAspectSupport
spring事务是通过AOP代理类中的advice（TransactionInterceptor)生效的。
该类是事务切面的基类（如transactionInterceptor或者AspectJ aspect)。通过该类，使得很容易的使用spring的底层事务基础设施，来为任何切面系统实现一个aspect（其实就是实现一个增强advice）
主要作用：
子类负责以正确的顺序，在当前类中调用方法；
策略模式，使用transactionManager的子类来执行真正的事务管理；
此外，TransactionAttributeSource用来确定特定类或事务方法的transactionDefinitions。
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
//当前由aop切面驱动的当前线程事务信息transactionInfo持有者---可获取当前事务的status、attribute所有信息
private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
new NamedThreadLocal<>("Current aspect-driven transaction");
@Nullable
private String transactionManagerBeanName;//事务管理器名称
@Nullable
private TransactionManager transactionManager; //事务管理器
@Nullable
private TransactionAttributeSource transactionAttributeSource; //事务属性解析源
@Nullable
private BeanFactory beanFactory; //spring中bean工厂类
//内部的功能性回调接口
@FunctionalInterface
protected interface InvocationCallback {
//实现拦截器链的调用
@Nullable
Object proceedWithInvocation() throws Throwable;
}
/**………………………………invokeWithinTransaction方法定义事务执行所有逻辑，包括执行事务、commit/rollback…………………… */
//transactionInterceptor的父类，实现调用事务方法的具体逻辑
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// 如果transaction attribute 为 null, 那么method是non-transactional.
TransactionAttributeSource tas = getTransactionAttributeSource();
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
//根据事务属性的getQualifier方法，决定事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
/**……………………………………………………………………TransactionManager为ReactiveTransactionManager……………………………………………… */
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
boolean isSuspendingFunction = KotlinDetector.isSuspendingFunction(method);
boolean hasSuspendingFlowReturnType = isSuspendingFunction &&
COROUTINES_FLOW_CLASS_NAME.equals(new MethodParameter(method, -1).getParameterType().getName());
if (isSuspendingFunction && !(invocation instanceof CoroutinesInvocationCallback)) {
throw new IllegalStateException("Coroutines invocation not supported: " + method);
}
CoroutinesInvocationCallback corInv = (isSuspendingFunction ? (CoroutinesInvocationCallback) invocation : null);
ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
Class<?> reactiveType =
(isSuspendingFunction ? (hasSuspendingFlowReturnType ? Flux.class : Mono.class) : method.getReturnType());
ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(reactiveType);
if (adapter == null) {
throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
method.getReturnType());
}
return new ReactiveTransactionSupport(adapter);
});
InvocationCallback callback = invocation;
if (corInv != null) {
callback = () -> CoroutinesUtils.invokeSuspendingFunction(method, corInv.getTarget(), corInv.getArguments());
}
Object result = txSupport.invokeWithinTransaction(method, targetClass, callback, txAttr, (ReactiveTransactionManager) tm);
if (corInv != null) {
Publisher<?> pr = (Publisher<?>) result;
return (hasSuspendingFlowReturnType ? KotlinDelegate.asFlow(pr) :
KotlinDelegate.awaitSingleOrNull(pr, corInv.getContinuation()));
}
return result;
}
/**……………………………………………………………………TransactionManager为PlatformTransactionManager……………………………………………… */
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
//获取事务方法拦截点的字符串信息
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
//当事务属性为null
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) { //1
// Standard transaction demarcation with getTransaction and commit/rollback calls.
//TAG1 createTransactionIfNecessary
//创建一个完整的事务信息TransactionInfo，其有getTransaction、commit、rollback方法
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
//事务方法是个around的advice，此处是执行拦截器链的操作，并最终调用目标类上的方法调用
retVal = invocation.proceedWithInvocation();
}
//如果抛出异常ex
catch (Throwable ex) {
//TAG2 completeTransactionAfterThrowing
// target invocation exception
//完成抛出异常后的事务执行
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
//清理事务信息info
cleanupTransactionInfo(txInfo);
}
if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
//TAG3 commitTransactionAfterReturning
//在执行结果返回后，commit事务
commitTransactionAfterReturning(txInfo);
return retVal;
} //1
//如果事务属性不为null---CallbackPreferringPlatformTransactionManager类型的事务管理器，不常用，代码忽略
else {
Object result;
final ThrowableHolder throwableHolder = new ThrowableHolder();
// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
try {
result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
try {
Object retVal = invocation.proceedWithInvocation();
if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
return retVal;
}
catch (Throwable ex) {
if (txAttr.rollbackOn(ex)) {
// A RuntimeException: will lead to a rollback.
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
else {
throw new ThrowableHolderException(ex);
}
}
else {
// A normal return value: will lead to a commit.
throwableHolder.throwable = ex;
return null;
}
}
finally {
cleanupTransactionInfo(txInfo);
}
});
}
catch (ThrowableHolderException ex) {
throw ex.getCause();
}
catch (TransactionSystemException ex2) {
if (throwableHolder.throwable != null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
ex2.initApplicationException(throwableHolder.throwable);
}
throw ex2;
}
catch (Throwable ex2) {
if (throwableHolder.throwable != null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
}
throw ex2;
}
// Check result state: It might indicate a Throwable to rethrow.
if (throwableHolder.throwable != null) {
throw throwableHolder.throwable;
}
return result;
}
}
//TAG1 createTransactionIfNecessary
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
// 如果事务没有命名
if (txAttr != null && txAttr.getName() == null) {
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
//设置joinpointIdentification为事务属性名称
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
if (txAttr != null) {
if (tm != null) {
/**……………………………………………………………………attribute----transactionManager转换为---->transactionStatus…………………………………… */
//从transactionManager获取事务，返回status
status = tm.getTransaction(txAttr);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
"] because no transaction manager has been configured");
}
}
}
//通过attribute、status创建出一个完整的事务信息transactionInfo
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, String joinpointIdentification,
@Nullable TransactionStatus status) {
//构建TransactionInfo
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
if (txAttr != null) {
if (logger.isTraceEnabled()) {
logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
}
txInfo.newTransactionStatus(status);
}
//如果attribute为null，表示当前不存在事务
else {
// The TransactionInfo.hasTransaction() method will return false. We created it only
// to preserve the integrity of the ThreadLocal stack maintained in this class.
if (logger.isTraceEnabled()) {
logger.trace("No need to create transaction for [" + joinpointIdentification +
"]: This method is not transactional.");
}
}
//无论是否存在事务，总是把transactionInfo设置到线程变量threadLocal上
txInfo.bindToThread();
return txInfo;
}
//TAG2 completeTransactionAfterThrowing
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
//如果事务信息info、status不为null
if (txInfo != null && txInfo.getTransactionStatus() != null) { //1
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
"] after exception: " + ex);
}
//如果事务属性不为空，且对当前异常ex进行回滚
if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
try {
//调用事务管理器transactionmanager进行事务回滚rollback
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
}
catch (TransactionSystemException ex2) {
logger.error("Application exception overridden by rollback exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by rollback exception", ex);
throw ex2;
}
} //2
//如果事务为空，或不对当前ex回滚，则执行commit（如果TransactionStatus.isRollbackOnly()为true，仍旧进行回滚）
else {
try {
//调用事务管理器进行回滚
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
catch (TransactionSystemException ex2) {
logger.error("Application exception overridden by commit exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by commit exception", ex);
throw ex2;
}
}
}
}
//TAG3 commitTransactionAfterReturning
protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
if (txInfo != null && txInfo.getTransactionStatus() != null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
}
//commit提交
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
}
invokeWithinTransaction方法定义事务执行所有逻辑，包括执行事务、commit/rollback。
6.2.3.3.1 TransactionInterceptor--(advice)
advice的实现类，对事务性方法执行，进行拦截。通过事务管理器plaformTransactionManager进行事务管理。
注意：TransactionInterceptor是线程安全的。
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
//初始化方法，需要事务管理器、事务属性源
public TransactionInterceptor(PlatformTransactionManager ptm, TransactionAttributeSource tas) {
setTransactionManager(ptm);
setTransactionAttributeSource(tas);
}
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// 确定目标类
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// 适配到父类TransactionAspectSupport的invokeWithinTransaction方法
//invocation是个invocationCallback接口，实现拦截器链的调用
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
6.2.3.3.2 TransactionInfo（TAS内部类）
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
private TransactionManager transactionManager;
private TransactionAttributeSource transactionAttributeSource;
private BeanFactory beanFactory;
//线程绑定的transactionInfo的holder类
private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
new NamedThreadLocal<>("Current aspect-driven transaction");
//内部类，事务信息，包括当前事务的manager、attribute、事务status、旧事务的info等信息
protected static final class TransactionInfo {
private final PlatformTransactionManager transactionManager;
private final TransactionAttribute transactionAttribute;
private final String joinpointIdentification;
private TransactionStatus transactionStatus;
//保存新旧的事务info
private TransactionInfo oldTransactionInfo;
private void bindToThread() {
//当前面old事务complete后，暴露当前事务info给线程
this.oldTransactionInfo = transactionInfoHolder.get();
transactionInfoHolder.set(this);
}
}
}
6.2.3.4 TransactionManager
transactionManager是spring事务管理的接口。
事务管理器的主要方法，以及相关的类
6.2.3.4.1 PlatformTransactionManager
spring事务的核心接口，application可以直接使用该类，但其并不仅仅是API接口。通常，application使用TransactionTemlate或者和AOP有所区别的声明性事务。
该类实现事务的传播行为并负责事务的同步处理。
public interface PlatformTransactionManager extends TransactionManager {
//返回当前active的事务，或者根据事务传播行为，创建一个新的事务返回-----开启事务
/** (根据事务的传播行为，返回有效的事务或者创建一个新事务：--执行逻辑如下：
1 隔离级别、超时时间，应用在新建事务；
2 如果事务定义不被transactionManager支持，抛异常)
3 根据当前是否存在事务，分别根据不同的传播行为，创建事务对象（如required、never等）*/
TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException;
//提交给定的事务--执行逻辑如下：
/**1 如果事务被标记rollback-only，执行rollback
2 如果先前事务被挂起suspend，用以创建新事务。那么commit事务后，恢复挂起的事务
3 commit完事务后，无论成功与否，事务必须完全完成并清理*/
void commit(TransactionStatus status) throws TransactionException;
//执行给定事务的回滚--执行逻辑如下：
/**1 如果事务不是新的，表示当前事务有外层事务，那么rollback仅仅设置标志位rollback-only，以参与外层事务；
2 如果之前的事务suspend（在创建新事务时候），那么rollback后恢复先前事务；
3 如果commit时抛出异常，不再调用rollback --???????????????*/
void rollback(TransactionStatus status) throws TransactionException;
}
6.2.3.4.2 AbstarctPlatformTransactionManager
抽象类，实现了spring事务的标准流程方法，为具体platformTransactionManager提供基础支持。
Manager主要作用：
负责实现整个事务管理和运行过程中的公共行为和通用逻辑的实现--------模版模式，子类实现具体方法，如begin、suspend、commit等。
getTransaction：
在事务管理器类AbstractPlatformTransactionManager中，getTransaction获取事务时，会处理不同的事务传播行为，例如当前存在事务，但调用方法事务传播级别为REQUIRES_NEW、PROPAGATION_NOT_SUPPORTED时，对当前事务进行挂起、恢复等操作，以此保证了当前数据库操作获取正确的Connection。
具体是在子事务提交的最后会将挂起的事务恢复，恢复时重新调用TransactionSynchronizationManager. bindResource设置之前的connection holder，这样再获取的连接就是被恢复的数据库连接， TransactionSynchronizationManager当前激活的连接只能是一个。
此基类提供以下工作流处理：
确定是否存在现有事务；
应用适当的传播行为；
在必要时暂停和恢复事务；
在提交时检查仅回滚标志；
对回滚应用适当的修改（实际回滚或设置仅回滚）；
触发注册的同步回调（如果事务同步处于活动状态）
子类需要实现begin/suspend/resume/commit/rollback等方法。
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
/**………………………………………………………………………………………………创建事务getTransaction……………………………………………………………………………………………… */
//事务管理器根据definition创建TransactionStatus（处理传播行为，创建事务）
@Override
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {
//如果没有提供TransactionDefinition，使用默认事务定义
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
//由子类实现，DataSourceTransactionManager.doGetTransaction创建事务对象（里面包含事务资源，如connection）
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
/**…………………………………………………………………………………………………………处理当前存在事务的情况…………………………………………………………………………………………………… */
if (isExistingTransaction(transaction)) {
//TAG1 handleExistingTransaction
//根据传播行为propagation behavior，解决如何创建事务的逻辑，创建transactionStatus
return handleExistingTransaction(def, transaction, debugEnabled);
}
// 检查新创建事务对象的超时时间，是否有效
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
/**…………………………………………………………………………………………………………处理当前不存在事务的情况…………………………………………………………………………………………………… */
//如果PROPAGATION_MANDATORY（必须在事务中执行），则抛异常
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
//如果传播行为是REQUIRED、REQUIRES_NEW、NESTED，则创建新的事务
else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
//因为不存咋事务，所以不需要挂起当前资源
SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {
logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
}
try {
//TAG2 startTransaction
//开启新事务
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error ex) {
resume(null, suspendedResources);
throw ex;
}
}
else {
//创建空事务：没有实际事务，但是任然可能同步
if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + def);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}
//TAG2 startTransaction
private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
//如果当前事务的TransactionSynchronization不为0，则表示是newSynchronization
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//开启事务，子类实现
doBegin(transaction, definition);
//TAG2.1 prepareSynchronization
//初始化事务同步管理器TransactionSynchronizationManager，以及其内的同步事务器
prepareSynchronization(status, definition);
return status;
}
//TAG2.1 prepareSynchronization
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
if (status.isNewSynchronization()) {
//TransactionSynchronizationManager属性设置
TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
definition.getIsolationLevel() : null);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
//初始化TransactionSynchronizationManager其内的事务同步器TransactionSynchronization
TransactionSynchronizationManager.initSynchronization();
}
}
/**………………………………………………………………处理当前存在事务情况，根据事务传播行为，执行事务创建逻辑……………………………………………………………… */
//TAG1 handleExistingTransaction
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
//never：以非事务运行，如果存在事务，抛异常
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
throw new IllegalTransactionStateException(
"Existing transaction found for transaction marked with propagation 'never'");
}
//NOT_SUPPORTED：以非事务运行，如果有事务，则挂起
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
if (debugEnabled) {
logger.debug("Suspending current transaction");
}
//挂起当前存在的事务
Object suspendedResources = suspend(transaction);
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
//准备TransactionStatus，且newTransaction为false，且保存挂起资源suspendedResources
return prepareTransactionStatus(
definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
//REQUIRES_NEW总是开启新事务；如果存在事务，则将这个存在的事务挂起，然后开启新事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
if (debugEnabled) {
logger.debug("Suspending current transaction, creating new transaction with name [" +
definition.getName() + "]");
}
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
//开启事务
return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {
resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}
//NESTED嵌套事务，创建一个嵌套事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
//判断是否允许嵌套实物
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'");
}
if (debugEnabled) {
logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
}
//使用savepoint作为嵌套事务
if (useSavepointForNestedTransaction()) {
//创建DefaultTransactionStatus，标志位newTransaction为false
DefaultTransactionStatus status =
prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
//创建事务，并持有savepoint
status.createAndHoldSavepoint();
return status;
}
else {
//嵌套的事务，通过被嵌套事务的begin、commit、rollback支持事务执行
return startTransaction(definition, transaction, debugEnabled, null);
}
}
//处理PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.支持当前事务
if (debugEnabled) {
logger.debug("Participating in existing transaction");
}
if (isValidateExistingTransaction()) {
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
Constants isoConstants = DefaultTransactionDefinition.constants;
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] specifies isolation level which is incompatible with existing transaction: " +
(currentIsolationLevel != null ?
isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
"(unknown)"));
}
}
if (!definition.isReadOnly()) {
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] is not marked as read-only but existing transaction is");
}
}
}
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
//准备事务状态status，设置newTransaction为false
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}
/**……………………………………………………………………………………………………rollback逻辑………………………………………………………………………………………………………………………… */
@Override
public final void rollback(TransactionStatus status) throws TransactionException {
//检查事务执行是否已经completed
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
//执行rollback逻辑
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
processRollback(defStatus, false);
}
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
try {
//非预期的rollback标记位
boolean unexpectedRollback = unexpected;
try {
//触发事务同步器TransactionSynchronization的beforeCompletion()
triggerBeforeCompletion(status);
//如果有savepoint点，回滚至savepoint（内层事务为nested，会开启保存点）
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Rolling back transaction to savepoint");
}
status.rollbackToHeldSavepoint();
}
//如果是新事务，则回滚事务，有两种情况
//1.最外层事务，事务是PROPAGATION_REQUIRED
//2.外层事务是PROPAGATION_REQUIRED，内层事务是PROPAGATION_REQUIRES_NEW
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction rollback");
}
//子类实现
doRollback(status);
}
else {
// 当前事务方法，参与更大的事务
if (status.hasTransaction()) {
if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
if (status.isDebug()) {
logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
}
//将事务标记为RollbackOnly，由外层事务进行回滚
/**这里设置RollbackOnly，status.getTransactionObject，然后获取其持有的connectionHolder中表示全局的rollback设置为true，表示全局事务需要回滚，外层事务判断globalRollback判断是否需要全局回滚 */
doSetRollbackOnly(status);
}
else {
if (status.isDebug()) {
logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
}
}
}
else {
logger.debug("Should roll back transaction but cannot - no transaction available");
}
// Unexpected rollback only matters here if we're asked to fail early
if (!isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = false;
}
}
}
catch (RuntimeException | Error ex) {
//触发事务同步回调方法TransactionSynchronization#afterCompletion()
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw ex;
}
//触发事务同步回调方法TransactionSynchronization#afterCompletion()
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
// Raise UnexpectedRollbackException if we had a global rollback-only marker
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction rolled back because it has been marked as rollback-only");
}
}
finally {
//清空记录的资源，并将挂起资源恢复
cleanupAfterCompletion(status);
}
}
/**……………………………………………………………………………………………………commit逻辑………………………………………………………………………………………………………………………… */
@Override
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");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
//如果当前事务状态为rollback，则回滚
if (defStatus.isLocalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
processRollback(defStatus, false);
return;
}
//如果全局事务状态为rollback，则回滚（在多层事务方法调用中出现）
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
}
processRollback(defStatus, true);
return;
}
//其他情况，进行事务commit
processCommit(defStatus);
}
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
try {
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
prepareForCommit(status);
//触发事务同步回调方法TransactionSynchronization#beforeCommit()
triggerBeforeCommit(status);
//触发事务同步回调方法TransactionSynchronization#beforeCompletion()
triggerBeforeCompletion(status);
beforeCompletionInvoked = true;
//如果有savepoint--此处不commit操作，仅仅释放savepoint
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Releasing transaction savepoint");
}
unexpectedRollback = status.isGlobalRollbackOnly();
status.releaseHeldSavepoint();
}
//如果没有savepoint，且当前事务是newTransaction
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction commit");
}
unexpectedRollback = status.isGlobalRollbackOnly();
//执行提交commit操作---子类实现
doCommit(status);
}
else if (isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = status.isGlobalRollbackOnly();
}
// Throw UnexpectedRollbackException if we have a global rollback-only
// marker but still didn't get a corresponding exception from commit.
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction silently rolled back because it has been marked as rollback-only");
}
}
catch (UnexpectedRollbackException ex) {
//触发事务同步回调方法TransactionSynchronization#afterCompletion()
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
}
catch (TransactionException ex) {
// can only be caused by doCommit
if (isRollbackOnCommitFailure()) {
//rollback
doRollbackOnCommitException(status, ex);
}
else {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
}
throw ex;
}
catch (RuntimeException | Error ex) {
if (!beforeCompletionInvoked) {
triggerBeforeCompletion(status);
}
doRollbackOnCommitException(status, ex);
throw ex;
}
// Trigger afterCommit callbacks, with an exception thrown there
// propagated to callers but the transaction still considered as committed.
try {
//触发事务同步回调方法TransactionSynchronization#afterCommit()
triggerAfterCommit(status);
}
finally {
//触发事务同步回调方法TransactionSynchronization#afterCompletion()
triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
}
}
finally {
cleanupAfterCompletion(status);
}
}
6.2.3.4.2.1 SuspendedResourcesHolder（内部类）
事务同步是一种通用机制，用于注册在事务完成时调用的回调。这主要由 JDBC、Hibernate、JPA 等的数据访问支持类在 JTA 事务中运行时在内部使用：它们注册在事务中打开的资源，在事务完成时关闭，例如用于在事务中重用相同的 Hibernate Session。同样的机制也可以用于应用程序中的自定义同步需求。
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
public static final int SYNCHRONIZATION_ALWAYS = 0;
public static final int SYNCHRONIZATION_ON_ACTUAL_TRANSACTION = 1;
public static final int SYNCHRONIZATION_NEVER = 2;
//该属性的setter/getter方法
private int transactionSynchronization = SYNCHRONIZATION_ALWAYS;
//final的getTransaction方法，无法覆盖，定义了事务执行的逻辑。保证获取事务流程的一致性
/**…………………………………………………………………………内部类--挂起的资源的holder………………………………………………………………………………*/
protected static final class SuspendedResourcesHolder {
//挂起资源
private final Object suspendedResources;
//当前事务上需要执行的TransactionSynchronization同步类
private List<TransactionSynchronization> suspendedSynchronizations;
private String name;
private boolean readOnly;
private Integer isolationLevel;
private boolean wasActive;
private SuspendedResourcesHolder(Object suspendedResources) {
this.suspendedResources = suspendedResources;
}
}
6.2.3.4.3 DataSourceTransctionManager
这个实现类，提供数据源DataSource。
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
implements ResourceTransactionManager, InitializingBean {
//事务创建和commit/rollback依赖于dataSource数据源创建的连接connection来实现
private DataSource dataSource;
//获取数据源
protected DataSource obtainDataSource() {
DataSource dataSource = getDataSource();
Assert.state(dataSource != null, "No DataSource set");
return dataSource;
}
//开启事务--模板方法实现类中调用，具体实现在该处
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try { //1
//如果txObject中没有connectionHolder
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) { //2
/** …………………………………………………………………………从DataSource新建connection…………………………………………………………………………*/
Connection newCon = obtainDataSource().getConnection();
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
} //2
//将当前connection资源标记为与实务同步
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
txObject.setReadOnly(definition.isReadOnly());
// 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.getAutoCommit()) { //2
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
//将connection的自动提交设置为false
con.setAutoCommit(false);
} //2
prepareTransactionalConnection(con, definition);
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// 如果是新建连接
if (txObject.isNewConnectionHolder()) { //2
/**………………将datasource:connectionHolder存入TransactionSynchronizationManager的ThreadLocal中 ……………………*/
TransactionSynchronizationManager.bindResource(obtainDataSource(),txObject.getConnectionHolder());
} //2
} //1
catch (Throwable ex) {
if (txObject.isNewConnectionHolder()) {
//释放当前DataSource创建的connection
DataSourceUtils.releaseConnection(con, obtainDataSource());
txObject.setConnectionHolder(null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
/** ……………………内部类：DataSource事务对象，代表一个connectionHolder对象。被manager用作事务对象…………………………*/
//存储ConnectionHolder等DataSource相关的事务信息
private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {
private boolean newConnectionHolder;
private boolean mustRestoreAutoCommit;
public void setConnectionHolder(@Nullable ConnectionHolder connectionHolder, boolean newConnectionHolder) {
//持有connectionHolder对象
super.setConnectionHolder(connectionHolder);
this.newConnectionHolder = newConnectionHolder;
}
}
}
6.2.3.4.3.1 DataSourceTransactionObject（内部类）
/**
DataSourceTransactionManager调用该事务对象，代表一个connectionHolder
可以通过事务对象DataSourceTransactionObject设置当前事务RollbackOnly只回滚的属性
*/
private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {
private boolean newConnectionHolder;
private boolean mustRestoreAutoCommit;
public void setConnectionHolder(@Nullable ConnectionHolder connectionHolder, boolean newConnectionHolder) {
super.setConnectionHolder(connectionHolder);
this.newConnectionHolder = newConnectionHolder;
}
//当前事务连接connection是否是新建的---表明当前是否是新创建的事务
public boolean isNewConnectionHolder() {
return this.newConnectionHolder;
}
public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) {
this.mustRestoreAutoCommit = mustRestoreAutoCommit;
}
public boolean isMustRestoreAutoCommit() {
return this.mustRestoreAutoCommit;
}
//事务属性RollbackOnly的设置
public void setRollbackOnly() {
getConnectionHolder().setRollbackOnly();
}
@Override
public boolean isRollbackOnly() {
return getConnectionHolder().isRollbackOnly();
}
@Override
public void flush() {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationUtils.triggerFlush();
}
}
}
transactionmanager通过DataSourceTransactionObject对事务的connection进行操作和设置，包括setRollbackOnly，来设置事务是否是只回滚的。
rollbackonly：事务只回滚属性
isNewConnectionHolder：如果connection是新创建的，代表是新事物
浙公网安备 33010602011771号