一文给你讲清楚Spring事务原理

传统事务的做法

我一开始问她知不知道假如没有Spring要怎么实现事务，她说知道，我就要他把传统事务的流程图画出来给我看下，下面就是她给出的流程图

A 获取连接

B 开启事务

C 执行CRUD

E 成功

F 失败

开始

Connection conn = DriverManager.getConnection

conn.getAutoCommit

conn.prepareStatement

CRUD是否成功?

提交事务

回滚事务

传统事务存在哪些问题

果然计算机科班出身的女朋友，技术底子还是阔以的[你强]，我再问她这种传统处理事务的方案有哪些局限或者短板呢？ 她说，除了CRUD的业务代码，还需要写事务管理相关的代码，平时的工作量就加大了，这个确实如此，传统的事务做法对程序员的工作量大大提高，同时也补充了我的看法： 1、传统事务代码与业务代码耦合，强度入侵业务代码，可扩展性差 2、如果一个业务功能里同时存在多个事务切换的时候，代码编写的就会非常复杂

正是为了解决这些缺陷,Spring团队就打造了Spring事务组件，这个模块组件封装了传统事务功能的逻辑，业务开发者不用关心事务管理代码，只管专注于业务开发，多么美哉！

Spring事务组件做了哪些伟大的事？

1、Spring定义了事务操作规范，提供了顶层统一的编程模型抽象，不管是Java事务API,还是Hibernate，下面就是Spring定义的顶层接口，规范了对事务操作定义：

public interface PlatformTransactionManager {
    //获取事务
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    //提交事务
    void commit(TransactionStatus var1) throws TransactionException;
    //回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}
复制代码

2、同时支持声明式事务和编程式事务 女朋友又开始问了，什么是编程式事务？什么是声明式事务呢？ 编程式事务和传统事务类似，它是和业务代码耦合在一起的，只不过Spring团队对事务管理进行了封装，提供了工具类

org.springframework.transaction.support.TransactionTemplate
复制代码

使用姿势如下面所示：

transactionTemplate.execute(() -> {
    //业务代码
    userService.addUser(user);
    scoreService.addScore(score);
});
复制代码

那什么是声明式事务呢？ 声明式事务就是通过注解的形式完成事务功能，如下面的代码可以等同于上面编程式事务，使我们的业务代码在事务中执行。

@Transactional
public void doTransaction() {
    userService.addUser(user);
    scoreService.addScore(score);
}
复制代码

Spring事务实现原理剖析

女朋友开始感兴趣了，这些Spring是如何做到的呢？

首先说编程式事务，这个比较简单，扒开他的源码可知，他就是通过将业务代码以函数表达式传入一个工具方法，方法里在执行业务代码前后织入事务管理的逻辑，如下面代码：

public class TransactionTemplate {

public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        	//获取数据库连接
            TransactionStatus status = transactionManager.getTransaction(this);
            Object result;
            try {
                //执行crud
                result = action.doInTransaction(status);
            } catch (Error | RuntimeException var5) {
                //异常回滚
                this.rollbackOnException(status, var5);
                throw var5;
            } catch (Throwable var6) {
                //异常回滚
                this.rollbackOnException(status, var6);
                throw new UndeclaredThrowableException(var6, "TransactionCallback threw undeclared checked exception");
            }
            //执行crud成功，提交事务
            this.transactionManager.commit(status);
            return result;
        }
    }
}    
复制代码

看到这个实现，就非常清楚了，Spring将事务管理代码和函数式编程结合完成了编程式事务的组装。

下面我重点讲下声明式事务的实现逻辑。

虽然表面上看着Spring通过一个注解就完成了事务的功能，实际上底层有很多的逻辑，它需要能够拦截事务方法，并且在事务方法前后嵌入事务管理逻辑，完成事务开启，提交，回滚等逻辑，在Spring生态中，AOP技术就是一种在方法前后嵌入一些通用代码的手段，确实如此，Spring声明式事务就是借助Spring的AOP能力实现的。 TransactionInterceptor就是Spring内部定义的一个切面，她实现了MethodInterceptor接口就像我们平时定义一个切面统一打印日志一样，这个切面是Spring内置的一个切面，专门用来处理数据库事务的。 在ProxyTransactionManagementConfiguration配置类中，对事务切面进行了定义

//定义拦截器
@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;
}
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
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;
}
复制代码

这样Spring容器启动之后，就有一个全局的事务切面了。拦截到@Transaction注解的方法时，会触发下面方法执行

public class TransactionInterceptor{
    @Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
                //在事务中执行目标方法
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}
}
复制代码

invokeWithinTransaction方法就是Spring事务嵌入事务管理方法到业务方法前后的具体实现了。看里面的源码就非常熟悉了，这个和编程式事务工具类TransactionTemplate的实现如出一辙，女朋友终于恍然大悟，原来是这样。

public class TransactionInterceptor{
    
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		TransactionAttributeSource tas = getTransactionAttributeSource();
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		//获取事务
		TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
		Object retVal = null;
		try {
			//执行目标方法crud
			retVal = invocation.proceedWithInvocation();
		}
		catch (Throwable ex) {
			// crud执行异常回滚事务
			completeTransactionAfterThrowing(txInfo, ex);
			throw ex;
		}
		finally {
			cleanupTransactionInfo(txInfo);
		}
		//提交事务
		commitTransactionAfterReturning(txInfo);
		return retVal;
		
	}
}
复制代码

看到这里，其实Spring声明式事务的实现思路非常清晰了，无非就是借助Spring的AOP能力，内置了一个切面，并且在事务方法前后织入了事务管理的操作。 女朋友非常高兴，今天我的晚餐又可以加鸡腿了

彩蛋

能够看到这里的朋友真的是非常感激，我相信技术的力量是无穷的。 最后给大家一个安利，Spring事务虽然封装好了，一个注解就可以完成事务的功能，但是有没有一种可能？你的功能需要感知你的业务代码的事务是成功还是失败了？Spring团队想到了这种可能，提供了一个口子给我们，这个就是事务同步器!!!，事务同步器是异步的，他会在事务提交前后通知到你，只要继承下面的抽象类即可。

public abstract class TransactionSynchronizationAdapter implements TransactionSynchronization, Ordered {

   @Override
   public int getOrder() {
      return Ordered.LOWEST_PRECEDENCE;
   }

   @Override
   public void suspend() {
   }

   @Override
   public void resume() {
   }

   @Override
   public void flush() {
   }

   @Override
   public void beforeCommit(boolean readOnly) {
   }

   @Override
   public void beforeCompletion() {
   }

   @Override
   public void afterCommit() {
   //这里可以感知事务提交完成
   }

   @Override
   public void afterCompletion(int status) {
   //这里感知事务完成
   }

}
复制代码

哈哈哈，这个实现有没有很优雅，每次看Spring的组件都会在心里给Spring团队的大神点赞，封装好组件给我们用，同时提供扩展点给我们，真的非常给力。 看到这个地方的朋友，有没有觉得可以get到一点新姿势新技能，有的话麻烦一键三连，哈哈哈哈。