springboot-事务失效以及排查过程

排查了好久，终于解决，希望这次的排查过程对大家也有帮助，废话少说，上源码

开发环境

springboot 2.3.11
jdk8
gradle6.4
HikariDataSource
ps: 本环节使用双数据源，在service层做切面拦截，切换具体的数据源

问题

在定义了具体的事务管理以后，想着不要手动切库，因为事务管理那里已经显示的注入了具体的数据源，然后结果导致的是事务失效，发生异常不回滚。代码如下

    @Override@Transactional(rollbackFor = Exception.class, transactionManager = DsConst.AGLOUD_TRANSACTION_MANAGER)public void ex() {jdbcTemplate.execute("insert into table_name1(name) values (1)");if (1 == 1) throw new RuntimeException("出异常了啊！！！！");jdbcTemplate.execute("insert into table_name2(name) values (1)");}

排查过程

第一步，先排查源码，spring拦截事务的拦截器是TransactionInterceptor类的invokeWithinTransaction方法，源码如下

@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, TransactionAspectSupport.InvocationCallback invocation) throws Throwable {TransactionAttributeSource tas = this.getTransactionAttributeSource();//1：获取事务属性配置信息：通过 TransactionAttributeSource.getTransactionAttribute解析@Trasaction注解得到事务属性配置信息TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;//2：获取事务管理器TransactionManager tm = this.determineTransactionManager(txAttr);//将事务管理器tx转换为 PlatformTransactionManagerPlatformTransactionManager ptm = this.asPlatformTransactionManager(tm);String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);//createTransactionIfNecessary内部，这里就不说了，内部主要就是使用spring事务硬//编码的方式开启事务，最终会返回一个TransactionInfo对象TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);//业务方法返回值Object retVal;try {//调用aop中的下一个拦截器，最终会调用到业务目标方法，获取到目标方法的返回值retVal = invocation.proceedWithInvocation();} catch (Throwable var18) {//3：异常情况下，如何走？可能只需提交，也可能只需回滚，这个取决于事务的配置this.completeTransactionAfterThrowing(txInfo, var18);throw var18;} finally {//清理事务信息this.cleanupTransactionInfo(txInfo);}if (retVal != null && vavrPresent && TransactionAspectSupport.VavrDelegate.isVavrTry(retVal)) {TransactionStatus status = txInfo.getTransactionStatus();if (status != null && txAttr != null) {retVal = TransactionAspectSupport.VavrDelegate.evaluateTryFailure(retVal, txAttr, status);}}//4：业务方法返回之后，只需事务提交操作this.commitTransactionAfterReturning(txInfo);return retVal;}

当我跟进去时候，发现事务并不是一个新的事务了，spring判断回滚的代码如下completeTransactionAfterThrowing,进去,最后执行到这里

private void processRollback(DefaultTransactionStatus status, boolean unexpected) {try {boolean unexpectedRollback = unexpected;try {triggerBeforeCompletion(status);if (status.hasSavepoint()) {status.rollbackToHeldSavepoint();}//判断是否是一个新的事务，如果是就回滚else if (status.isNewTransaction()) {doRollback(status);}

我很疑惑，为什么不是一个新的事务，而且我也没有整嵌套事务什么花里胡哨的东西，怎么就不是新的事务了。于是我另外起了一个项目对比debugger,好久才发，具体如下

乍一看，我是不是眼花了！！！为什么目标对象和代理对象都是代理对象呢。我xx，Cglib创建代理的时候，是可以代理类也再创建代理的吗？本着求真务实的精神，用cglib的原生Api做了测试，发生会报错，不能这样子。代码如下

package com.shiguiwu.springmybatis.spring.aop.cglib;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;/*** @description: callbak* 1. Cglib根据父类,Callback, Filter 及一些相关信息生成key* 2. 然后根据key 生成对应的子类的二进制表现形式* 3. 使用ClassLoader装载对应的二进制,生成Class对象,并缓存* 4. 最后实例化Class对象,并缓存* @author: stone* @date: Created by 2021/5/18 19:54* @version: 1.0.0* @pakeage: com.shiguiwu.springmybatis.spring.aop.cglib*/
public class CglibCallbackObjTest {interface Service1 {void m1();}interface Service2 {void m2();}public static class Service implements Service1, Service2 {@Overridepublic void m1() {System.out.println("m1");}@Overridepublic void m2() {System.out.println("m2");}}public static void main(String[] args) {Enhancer enhancer = new Enhancer();//设置父类enhancer.setSuperclass(Service.class);//设置代理对象需要实现的接口enhancer.setInterfaces(new Class[]{Service1.class, Service2.class});//通过Callback来对被代理方法进行增强enhancer.setCallback((MethodInterceptor) (o, method, objects, methodProxy) -> {long l = System.nanoTime();Object result = methodProxy.invokeSuper(o, objects);System.out.println(method.getName() + "耗时为：" + (System.nanoTime() - l));return result;});Object proxy = enhancer.create();//if (proxy instanceof Service) {//    ((Service) proxy).m1();//    ((Service) proxy).m2();//}System.out.println("父类" + proxy.getClass().getSuperclass());System.out.println(proxy.getClass());System.out.println("创建代理类实现的接口如下：");for (Class<?> cs : proxy.getClass().getInterfaces()) {System.out.println(cs);}Enhancer enhancer1 = new Enhancer();enhancer1.setSuperclass(proxy.getClass());enhancer1.setCallback((MethodInterceptor) (o, method, objects, methodProxy) -> {long l = System.nanoTime();Object result = methodProxy.invokeSuper(o, objects);System.out.println(method.getName() + "耗时11为：" + (System.nanoTime() - l));return result;});Object proxy1 = enhancer1.create();System.out.println("父类" + proxy1.getClass().getSuperclass());System.out.println(proxy1.getClass());//if (proxy1 instanceof Service) {//    ((Service) proxy1).m1();//    ((Service) proxy1).m2();//}}}

运行这段代码会报错

Exception in thread "main" org.springframework.cglib.core.CodeGenerationException: java.lang.ClassFormatError-->Duplicate method name&signature in class file com/shiguiwu/springmybatis/spring/aop/cglib/CglibCallbackObjTest$Service$$EnhancerByCGLIB$$c12e4df0$$EnhancerByCGLIB$$eed200b8at org.springframework.cglib.core.ReflectUtils.defineClass(ReflectUtils.java:538)at org.springframework.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:363)at org.springframework.cglib.proxy.Enhancer.generate(Enhancer.java:585)at org.springframework.cglib.core.AbstractClassGenerator$ClassLoaderData$3.ap

但是，要知道，spring鬼的很，说不定他就是可以的，结果测试代码，发现，spring基于cglib创建的代理是可以，他会判断当前的目标对象是不是代理对象，如果是,则以目标对象的父类来创建代理对象，但是目标对象还是代理对象。代码org.springframework.aop.framework.CglibAopProxy#getProxy(@Nullable ClassLoader classLoader) 如下

	try {Class<?> rootClass = this.advised.getTargetClass();Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");Class<?> proxySuperClass = rootClass;//判断目标对象是不是代理对象if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {proxySuperClass = rootClass.getSuperclass();Class<?>[] additionalInterfaces = rootClass.getInterfaces();for (Class<?> additionalInterface : additionalInterfaces) {this.advised.addInterface(additionalInterface);}}

这个时候，我们需要了解springbean的生命周期了，spring是什么时候，偷梁换柱的，把目标对象变成代理对象。现有我知道的就是引入@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)注解，然后spring向容器中添加了一个AnnotationAwareAspectJAutoProxyCreator，这个类很重要，它是一个SmartInstantiationAwareBeanPostProcessor的子类，他就是springbean在初始化后调用的方法，然后判断bean 需不需要生成代理对象。主要逻辑在抽象类AbstractAutoProxyCreator#postProcessAfterInitialization

      @Overridepublic Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {if (bean != null) {Object cacheKey = getCacheKey(bean.getClass(), beanName);if (this.earlyProxyReferences.remove(cacheKey) != bean) {return wrapIfNecessary(bean, beanName, cacheKey);}}return bean;}

然后我把断点打到这个位置，因为类比较多，为了不干扰我们调试，使用条件debugger，具体如下

最终发现，有在创建代理对象的时候，上面的方法进了两次。然后发现他们是不同的类进来的，原来我项目代码中，创建代理用到了两个类分别是AnnotationAwareAspectJAutoProxyCreator和DefaultAdvisorAutoProxyCreator。这个两个类型具有相同的父类，也是BeanPostProcessor，也会拦截bean的创建过程。

但是我本地的项目主要AnnotationAwareAspectJAutoProxyCreator，于是为了模拟现场的环境，我手动注入了DefaultAdvisorAutoProxyCreator，最后发现本地是跟上次的情况一样，创建了嵌套代理。

@Beanpublic DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);return defaultAdvisorAutoProxyCreator;}

那是不是因为嵌套代理让事务失效呢，最后的答案是：不是。本地照样能回滚，原来我第一个打点断的时候，只关注了是不是新事务，但是spring aop是一个方法调用链,所以当旧的事务通过调用栈出来的时候，这个事务就是一个新事务，也执行了回滚操作.

心累。。。
然后我在想是不是postgres没有开启事务支持呢，或者是数据库需要手动设置事务支持。通过实验我又排除了这个可能。代码如下

   @Autowiredprivate DataSource dataSource;@Resourceprivate DataSource masterDataSource;@Testpublic void tx() {JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);//1.定义一个事务管理器PlatformTransactionManager transactionManager = new DataSourceTransactionManager(masterDataSource);boolean a = true;//清空数据jdbcTemplate.update("truncate table table_name1");System.out.println("PROPAGATION_REQUIRED start ==========================================================");//2.定义一个事务属性TransactionDefinition transactionDefinition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED);//3.取一个事务状态,开启事务了TransactionStatus transactionStatus = transactionManager.getTransaction(transactionDefinition);//设置扩展点//addSynchronization("ts-1", 2);//        //addSynchronization("ts-2", 1);try {//4.执行业务jdbcTemplate.execute("insert into table_name1(name) values (1)");if (a) {throw new RuntimeException("===");}//jdbcTemplate.update("insert into book(book_name) values (?)", "成是非");jdbcTemplate.execute("insert into table_name1(name) values (100)");//此时，在执行一个方法事务//other(jdbcTemplate, transactionManager);//5.提交事务System.out.println("PROPAGATION_REQUIRED 准备commit");transactionManager.commit(transactionStatus);System.out.println("PROPAGATION_REQUIRED commit完毕");} catch (Exception e) {e.printStackTrace();//6.回滚事务：platformTransactionManager.rollbacktransactionManager.rollback(transactionStatus);}System.out.println("after==========================>:" + jdbcTemplate.queryForList("SELECT * from table_name1"));}

经过上面代码，最终发现，JdbcTemplate 的数据源和PlatformTransactionManager 管理器的数据源不是同一个，为什么不是同一个就失效呢？这里需要了解spring内部是怎么控制事务的。
这里简单说一下，源码不是我们的重点：
spring在开始事务之前，会在事务管理器中拿数据源，通过该数据源获取一个数据库连接，同时将数据库连接设置为手动提交，然后通过ThreadLocal绑定到当前线程中，绑定的格式map类型datasource->ConnectionHolder。再来就是执行业务了，jdbcTemplate中有数据源，这个时候，重点来了啊。根据jdbcTemplate的数据源，从本地线程中拿连接，此时由于数据源不一样，根本拿不到连接，spring帮我们本次数据源中再创建一个连接，用此时的连接执行sql，然后自动提交了。而我们保存线程本地的连接一直没干活，所以事务失效！

再次排查

于是呢，我在事务方法哪里又手动进行切库，这回总该数据源一致了吧。虽然说是动态数据源，但是具体返回的数据源应该由我来设置的。

但是，事与愿违，还是不行，于是我在切库的切面那里打了个断点，代码如下

然后发现，代码居然是先执行了事务拦截器，在执行的切面，炸了啊。怎么可能呢，查资料也是事务拦截器优先级很低的，但是不管你怎么设置的切面顺序，始终但是先执行的事务拦截器。也就是说，事务管理里的数据源，不管你怎么切换，始终都是默认的数据源，这样就实现不了其他库的事务控制。最后回到最开始的问题，有一个事务拦截器是代理的代理，切面是目标对象的代理，所以不管你怎么设置，代理的代理方法始终是最先执行的。

最后整个人都麻了，然后只能从为什么有两个代理生成器的人手，最后通过寻找，在jar里面，有人显示注入了DefaultAdvisorAutoProxyCreator，这个是由于项目遗留的bug，将那个源码改掉就解决了。