有没有觉得在Spring 中使用事务很简单,完全不用了解事务,只知道需要加事务地方,加上 @Transactional
注解就好了。
是不是很简单?
但是,正因为封装的这么好,开发人员集中精力在业务开发上,那么很有可能忽略很多数据库一些特性以及觉得对 @Transactional
很了解,就是事务嘛。
以下几个问题可以思考下:
- 数据库事务隔离级别有哪些?
@Transactional
操作事务隔离级别怎么对应上的?- 嵌套事务怎么回事?
- 内部调用(this)事务方式,会生效吗?
…
带着这些问题,从本章开始抽丝剥茧,看看Spring如何实现生声明式事务的。
本文还是基于SpringBoot进行分析
SpringBoot tx入口
在 transaction
子包下面,有一个 @Configuration
注解的类TransactionAutoConfiguration
:
@Configuration
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class, Neo4jDataAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public TransactionManagerCustomizers platformTransactionManagerCustomizers(
ObjectProvider<PlatformTransactionManagerCustomizer<?>> customizers) {
return new TransactionManagerCustomizers(customizers.orderedStream().collect(Collectors.toList()));
}
@Configuration
@ConditionalOnSingleCandidate(PlatformTransactionManager.class)
public static class TransactionTemplateConfiguration {
private final PlatformTransactionManager transactionManager;
public TransactionTemplateConfiguration(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
@Bean
@ConditionalOnMissingBean
public TransactionTemplate transactionTemplate() {
return new TransactionTemplate(this.transactionManager);
}
}
@Configuration
@ConditionalOnBean(PlatformTransactionManager.class)
@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
public static class EnableTransactionManagementConfiguration {
@Configuration
@EnableTransactionManagement(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
matchIfMissing = false)
public static class JdkDynamicAutoProxyConfiguration {
}
@Configuration
@EnableTransactionManagement(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
public static class CglibAutoProxyConfiguration {
}
}
}
上面Configuration将在Spring Boot项目启动时加载。
@ConditionalOnClass
开头接口将依据 类路径下是否有PlatformTransactionManager
类,决定是否加载该配置类。当引入spring-tx
包后,这一步条件将通过@AutoConfigureAfter
将限制,需要在JtaAutoConfiguration
、HibernateJpaAutoConfiguration
、DataSourceTransactionManagerAutoConfiguration
、Neo4jDataAutoConfiguration
加载后再加载 当前类。@EnableConfigurationProperties(TransactionProperties.class)
声明数据绑定对象。
其实Spring 的中事务有两种实现方式,一种是Proxy,即代理的方式。另一种则是 AspectJ
方式。
两者区别简单来说就是如下几点:
- AspectJ的功能更加全面和强大。支持全部的Pointcut类型。
- 毕竟Spring作为一个以集成起家的框架,在设计Spring AOP的时候也是为了减轻开发人员负担而做了不少努力的。它提供的开箱即用(Out-of-the-box)的众多AOP功能让很多开发人员甚至都不知道什么是AOP
- Spring AOP: 基于代理(Proxying) AspectJ: 基于字节码操作(Bytecode Manipulation)
如果想使用AspectJ
方式,则需要制定aspectJ的agent。
本文主要围绕Proxy类型事务进行研究,当然两种方式,博主都有具体例子:
AspectJ
Proxy
上面SpringBoot的auto-config 经过对bean和class存在性判断后,其实主要起作用的bean为 @EnableTransactionManagement(proxyTargetClass = false)
EnableTransactionManagement
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
...
}
再看 具体的 TransactionManagementConfigurationSelector
类:
@Override
protected String[] selectImports(AdviceMode adviceMode) {
switch (adviceMode) {
case PROXY:
return new String[] {AutoProxyRegistrar.class.getName(),
ProxyTransactionManagementConfiguration.class.getName()};
case ASPECTJ:
return new String[] {determineTransactionAspectClass()};
default:
return null;
}
}
private String determineTransactionAspectClass() {
return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ?
TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :
TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
}
以Proxy分析的话,EnableTransactionManagement
引入了两个类:AutoProxyRegistrar
和 ProxyTransactionManagementConfiguration
。
AutoProxyRegistrar
主要为配置AOP代理模式,如果有则不需要配置。
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean candidateFound = false;
Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
for (String annType : annTypes) {
AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
if (candidate == null) {
continue;
}
Object mode = candidate.get("mode");
Object proxyTargetClass = candidate.get("proxyTargetClass");
if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
Boolean.class == proxyTargetClass.getClass()) {
candidateFound = true;
if (mode == AdviceMode.PROXY) {
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
if ((Boolean) proxyTargetClass) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
return;
}
}
}
}
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
中,如果系统已经注册过AOP代理工厂了(例如直接配置SpringAop),则强行更改其代理模式(proxyTargetClass)为 true,即强行使用cglib代理。
ProxyTransactionManagementConfiguration
@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
// 声明一个Advisor
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
advisor.setTransactionAttributeSource(transactionAttributeSource());
advisor.setAdvice(transactionInterceptor());
if (this.enableTx != null) {
advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
}
return advisor;
}
// 用于解析注解参数
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}
// 声明一个拦截器 即Advice
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionInterceptor transactionInterceptor() {
TransactionInterceptor interceptor = new TransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource());
if (this.txManager != null) {
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
}
Spring Transaction
工具Bean
类已经都定义完了,这么少吗?
确实是的,如果看过博主前面分析Spring Aop
原理文章,则能大概猜出Spring Transaction
是利用Aop
进行方法级别切入,并在其中配置事务操作的。
BeanFactoryTransactionAttributeSourceAdvisor
先看看 BeanFactoryTransactionAttributeSourceAdvisor
的类结构:
而 BeanFactoryTransactionAttributeSourceAdvisor
中有一个 TransactionAttributeSourcePointcut
字段,即 Advisor有PointCut拦截,还有 具体切入点的 MethodInterceptor
。
pointcut内部的matches方法又是如何实现的呢?
@Override
public boolean matches(Method method, Class<?> targetClass) {
if (TransactionalProxy.class.isAssignableFrom(targetClass) ||
PlatformTransactionManager.class.isAssignableFrom(targetClass) ||
PersistenceExceptionTranslator.class.isAssignableFrom(targetClass)) {
return false;
}
// 获取BeanFactoryTransactionAttributeSourceAdvisor 中传入的TransactionAttributeSource
TransactionAttributeSource tas = getTransactionAttributeSource();
// 即当方法有Transaction注解时候,需要spring aop进行切入
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
getTransactionAttribute
方法比较容易理解,感兴趣可以自行查看。
TransactionInterceptor
如果匹配上了,怎么处理呢?具体组装逻辑则是通过Spring Aop进行组装。首先进入DynamicAdvisedInterceptor
的 intercept
方法通用AOP拦截,而后根据不同拦截器链,调用到 TransactionInterceptor
的 invoke
方法:
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// Work out the target class: may be {@code null}.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface.
// 得出当前类
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// Adapt to TransactionAspectSupport's invokeWithinTransaction...
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
invokeWithinTransaction
方法如下:
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// If the transaction attribute is null, the method is non-transactional.
// 获取 TransactionAttributeSource
TransactionAttributeSource tas = getTransactionAttributeSource();
// 获取注解参数
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 决定使用哪个事务管理器,这个可以在注解上定义 默认事务管理器为 :DataSourceTransactionManager,如果要做主从库等,可以自己定义后修改
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
// 获取方法完整名字
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
// 标准事务管理
// Standard transaction demarcation with getTransaction and commit/rollback calls.
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
Object retVal;
try {
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
commitTransactionAfterReturning(txInfo);
return retVal;
}
else {
// 编程式事务管理,或者没有声明注解,直接执行,但是会记录错误信息。
final ThrowableHolder throwableHolder = new ThrowableHolder();
// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
try {
Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
try {
return invocation.proceedWithInvocation();
}
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);
}
});
// Check result state: It might indicate a Throwable to rethrow.
if (throwableHolder.throwable != null) {
throw throwableHolder.throwable;
}
return result;
}
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;
}
}
}
其实看上述方法结构,也大概有了理解了,基本的事务操作如下:
getConnection();
try{
doSomeThing();
}catch(Exception e){
rollback();
}finally{
reset();
}
commit();
- 解析注解,获取注解声明的事务管理器
- 判断事务管理器类型,决定是否走通用声明式事务处理方法
- 没有声明事务,或者使用函数式事务
CallbackPreferringPlatformTransactionManager
,则直接往下执行,并且记录相应的 错误 - 声明事务,则走try{}catch{}finally{} 模板逻辑处。
下面对这几个快方法进行具体方法
数据准备阶段
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
Spring 事务管理中,有 多种可选的参数:
public @interface Transactional {
// 事务管理器
@AliasFor("transactionManager")
String value() default "";
// 事务管理器别名
@AliasFor("value")
String transactionManager() default "";
// 事务传递属性,默认是 REQUIRED
Propagation propagation() default Propagation.REQUIRED;
// 事务隔离级别
Isolation isolation() default Isolation.DEFAULT;
// 事务超时时间
int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
// 判断事务是否只读
boolean readOnly() default false;
// 导致事务回滚的异常类数组,只能是 Throwable 子类
Class<? extends Throwable>[] rollbackFor() default {};
// 异常时抛出错误名
String[] rollbackForClassName() default {};
// 不会导致事务回滚的异常类
Class<? extends Throwable>[] noRollbackFor() default {};
Class<? extends Throwable>[] noRollbackFor() default {};
}
其他的不用过多说,难以理解的为 propagation
、isolation
、rollbackFor
。
当然对于 isolation
事务隔离级别,则是说明当前执行回话事务隔离级别,和数据库中对应的。
propagation
为事务传播特性,主要有以下几种:
- TransactionDefinition.PROPAGATION_REQUIRED: 如果当前有事务,则加入,否则新建事务
- TransactionDefinition.PROPAGATION_SUPPORTS:如果当前有事务,则加入,否则不建立新事务
- TransactionDefinition.PROPAGATION_MANDATORY:如果当前有事务,则加入,否则报错
- TransactionDefinition.PROPAGATION_REQUIRES_NEW:创建新事务;如果当前有事务,则暂停。
- TransactionDefinition.PROPAGATION_NOT_SUPPORTED:如果当前事务存在,那么会暂停当前事务,并且方法内部使用非事务方式运行
- TransactionDefinition.PROPAGATION_NEVER:不允许有事务,如果当前事务已经存在,则报错
- TransactionDefinition.PROPAGATION_NESTED:如果存在事务,则在嵌套事务执行,没有事务,则新建事务。
前六个策略类似于EJB CMT,第七个(PROPAGATION_NESTED)是Spring所提供的一个特殊变量。
它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为(如Spring的DataSourceTransactionManager)
图片转自: https://blog.csdn.net/yanxin1213/article/details/100582643
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
// 如果没有定义事务名称,则使用方法作为事务名称
if (txAttr != null && txAttr.getName() == null) {
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
if (txAttr != null) {
if (tm != null) {
// 获取事务状态
status = tm.getTransaction(txAttr);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
"] because no transaction manager has been configured");
}
}
}
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
最开始获取事务名称,而后获取事务状态:
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
// 获取当前线程所拥有连接
Object transaction = doGetTransaction();
// Cache debug flag to avoid repeated checks.
boolean debugEnabled = logger.isDebugEnabled();
if (definition == null) {
// Use defaults if no transaction definition given.
definition = new DefaultTransactionDefinition();
}
if (isExistingTransaction(transaction)) {
// 如果是已经存在的事务,则根据传递级别 propagation去进行不同操作
// 判断方式就是当前线程是否已经有事务,有就说明已有事务
// Existing transaction found -> check propagation behavior to find out how to behave.
return handleExistingTransaction(definition, transaction, debugEnabled);
}
以下处理,都是基于没有事务进行
// Check definition settings for new transaction.
// 判断超时时间
if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
}
// No existing transaction found -> check propagation behavior to find out how to proceed.
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
// 如果是 PROPAGATION_MANDATORY 类型传递,但是当前没有事务,就报错。
throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 如果是这三种 PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED
// 暂停当前事务,并获取当前异步事务
SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {
logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
}
try {
// 当前事务,是否需要暂停
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 创建一个事务状态
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 使用当前连接,配置当前连接,设置autoCommit,timeout,去preparestatement等等。
doBegin(transaction, definition);
// 如果当前操作是首次线程操作,那么需要设置当前线程一些值
prepareSynchronization(status, definition);
return status;
}
catch (RuntimeException | Error ex) {
resume(null, suspendedResources);
throw ex;
}
}
else {
// 无事务
// Create "empty" transaction: no actual transaction, but potentially synchronization.
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + definition);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 设置一些 当前线程的状态TransactionSynchronizationManager
return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
}
}
上面获取完事务状态后,调用 prepareTransactionInfo
构造出一份 TransactionInfo
返回。
执行方法阶段
执行方法,是直接调用下一次拦截,
retVal = invocation.proceedWithInvocation();
即默认 事务切面会优先于 @Advice
注解产生切面。最终整个调用方法栈,即如果其他切面逻辑报错,也会导致其回滚。
异常处理
当栈进栈出之后,如果报错,则会进入catch块:
catch (Throwable ex) {
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
看看 completeTransactionAfterThrowing
方法:
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
if (txInfo != null && txInfo.getTransactionStatus() != null) {
// 如果有设置事务传递信息,以及事务隔离信息
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
"] after exception: " + ex);
}
// 如果配置的ex,是抛出异常的父类,那么久进入抛出阶段。
if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
try {
// 回滚
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;
}
}
else {
// 否则,这样的错误不会回滚。
// We don't roll back on this exception.
// Will still roll back if TransactionStatus.isRollbackOnly() is true.
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;
}
}
}
}
而回滚之后,就会利用上面Spring 中定义的事务传递进行选择了。
回滚操作
@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);
}
主要工作在 processRollback
:
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
try {
// 获取配置的开关,如果是未期待错误处理
boolean unexpectedRollback = unexpected;
try {
// 如果有配置 TransactionSynchronization 的 beforeCompletion 操作,则会触发。
triggerBeforeCompletion(status);
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Rolling back transaction to savepoint");
}
// 如果有保存点,则会执行 rollbackToHeldSavepoint 进行单独回滚,回滚到savepoint,并将savepint清空
status.rollbackToHeldSavepoint();
}
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction rollback");
}
// 普通回滚,获取本次Connection直接回滚
doRollback(status);
}
else {
// 一次大事务
// Participating in larger transaction
if (status.hasTransaction()) {
if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
if (status.isDebug()) {
logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
}
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) {
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 {
// 清除信息,包括DefaultTransactionStatus 和 当前线程信息状态,放回连接等
cleanupAfterCompletion(status);
}
}
清除信息
finally块中有一个方法,无论成功还是失败,都会执行
cleanupTransactionInfo(txInfo);
主要目的为设置当前事务线程的TransactionInfo
信息到ThreadLocal
中。
提交事务
如果整个过程没有报错,那么就会执行:
commitTransactionAfterReturning(txInfo);
来执行提交事务操作。
具体看 AbstractPlatformTransactionManager
的 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-only,那么还是会调用回滚方法,即不报错,但是手动回滚
if (defStatus.isLocalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
processRollback(defStatus, false);
return;
}
// 设置了globeOnly,也会回滚。并会设置不期待的回滚
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;
}
// 执行事务提交动作
processCommit(defStatus);
}
大概代码流程,都在代码中带有注释,对于具体事务提交都当做,却做了很多事:
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
try {
// 设置标记变量
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
prepareForCommit(status);
// 触发TransactionSynchronization 中 beforeCommit 操作
triggerBeforeCommit(status);
triggerBeforeCompletion(status);
beforeCompletionInvoked = true;
if (status.hasSavepoint()) {
// 如果有savepoint
if (status.isDebug()) {
logger.debug("Releasing transaction savepoint");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// 释放安全点
status.releaseHeldSavepoint();
}
else if (status.isNewTransaction()) {
// 新事务
if (status.isDebug()) {
logger.debug("Initiating transaction commit");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// 具体提交事务操作,就是connection.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) {
// 如果被标记为rollback-only,则也要抛出异常,就算commit了,也要跑出来
throw new UnexpectedRollbackException(
"Transaction silently rolled back because it has been marked as rollback-only");
}
}
catch (UnexpectedRollbackException ex) {
// can only be caused by doCommit
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
}
catch (TransactionException ex) {
// can only be caused by doCommit
if (isRollbackOnCommitFailure()) {
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);
}
}
总结
整个事务逻辑,简略来说就是如下面的伪代码,而Spring在此基础上丰富了事务操作,并且简化了编程,我们只需要一个注解就可以完成:
getConnection();
try{
doSomeThing();
}catch(Exception e){
rollback();
}finally{
reset();
}
commit();
其中,Spring Transaction提供了事务接入点,可对事务执行阶段进行通知,当然可以自行增加相关组件实现。
觉得博主写的有用,不妨关注博主公众号: 六点A君。
哈哈哈,一起研究Spring: