Spring事务失效的案例详解，以及解决方案，一篇带你了解Spring事物失效

1. 首先来看一段代码

@Transactional
public void getUser(Long id) {
    User user = new User("","",5L,"4",4,"44");
    userMapper.updateById(user);
    testTransactional();
}
public void testTransactional(){
    User user = new User("","",2L,"2",2,"22");
    userMapper.updateById(user);
    int i=10/0;
    user.setId(3L);
    userMapper.updateById(user);
}

这样testTransactional()的事务会生效吗？
答案是肯定的，在spring中默认的事务级别是PROPAGATION_REQUIRED。因此即使被调用的方法没有显示写上@Transactional也会被包含在当前事务中，如果发生异常就一起回滚

2. 但是当我们稍微修改一下代码：

public void getUser(Long id) {
    User user = new User("","",5L,"4",4,"44");
    userMapper.updateById(user);
    testTransactional();
}
@Transactional
public void testTransactional(){
    User user = new User("","",2L,"2",2,"22");
    userMapper.updateById(user);
    int i=10/0;
    user.setId(3L);
    userMapper.updateById(user);
}

记住Spring事务的实现是通过AOP来实现的。所以调用的时候是通过被代理类来调用其中的方法
这样getUser()在调用testTransactional()的时候还有有事务吗。答案是否定的。
因为getUser()这个方法并没有被增强，调用的testTransactional()是被代理对象的testTransactional()，testTransactional()方法没有被增强。因此就不会有事务的产生。
如果是通过依赖注入，或者getBean()方法得到的对象是代理对象，这样调getUser()，其实调的是被增强的方法。
所以本质一定要看你获得的是什么对象，是代理对象还是被代理对象，只有代理对象的方法被增强了，被代理对象永远不会被增强，因为我们的业务逻辑中没有增强的逻辑。

3. 让我们在修改一下代码

@Transactional
public void getUser(Long id) {
    User user = new User("","",5L,"4",4,"44");
    userMapper.updateById(user);
    testService.testTransactional();
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testTransactional(){
    User user = new User("","",2L,"2",2,"22");
    userMapper.updateById(user);
    int i=10/0;
    user.setId(3L);
    userMapper.updateById(user);
}

记住Spring事务的实现是通过AOP来实现的。所以调用的时候是通过被代理类来调用其中的方法
这样testTransactional()的事务传播级别会生效吗，答案也是否定的。
因为他们发生了自身的调用，并没有使用到代理类，因此testTransactional()也是被代理对象的方法。具体原理同上！！
对于这个问题有什么解决办法呢？

1. 最简单且合理的方法就是将testTransactional()抽取出来，使用@Autowired将新的类注入到当前类中，这样是肯定可以触发事务传播级别的
2. 自己注入自己，但是如果实用构造方法注入，spring不能自动解决循环依赖的问题，需要加上@Lazy
3. 在主程序类中添加@EnableAspectJAutoProxy(exposeProxy = true)并且别忘了添加依赖：

<dependency>
  <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
</dependency>
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
</dependency>

@Transactional
public void getUser(Long id) {
    User user = new User("", "", 5L, "4", 4, "44");
    userMapper.updateById(user);
    TestServiceImpl testService = (TestServiceImpl) AopContext.currentProxy();
    testService.testTransactional();
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testTransactional() {
    User user = new User("", "", 2L, "2", 2, "22");
    userMapper.updateById(user);
    int i = 10 / 0;
    user.setId(3L);
    userMapper.updateById(user);
}

使用代理类

4. 如果这样结果会是什么呢
   答案还是全部回滚。因为在testTransactional()抛出了异常，同时getUser(Long id)也会抛出异常，即使这两个方法不是同一个事务，也会一起回滚。但是如果在getUser(Long id)加入了try catch那么就只有testTransactional()会抛出异常

5. 如果在getUser的最后出现了异常，testTransactional()会回滚吗？
   不会 因为使用的都不是一个事务，因此不会回滚

@Transactional
public void getUser(Long id) {
    User user = new User("", "", 5L, "4", 4, "44");
    userMapper.updateById(user);
    TestServiceImpl testService = (TestServiceImpl) AopContext.currentProxy();
    testService.testTransactional();
    int i = 10 / 0;
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testTransactional() {
    User user = new User("", "", 2L, "2", 2, "22");
    userMapper.updateById(user);
    user.setId(3L);
    userMapper.updateById(user);
}

6. @Configuration：最后一种也是最容易被忽略的一种，当我们没有使用Springboot的时候，需要自己注入JdbcTemplate和PlatformTransactionManager，如图：
   
7. 可以看到这里都调用了dataSource()方法来生成一个dataSource对象，当我们如果没有在这个类上使用@Configuration注解时，每次调用dataSource()都会产生一个新的dataSource对象。而Spring事务如何保证是同一个数据库连接呢？就是通过ThreadLocal<Map<DataSource,Connnection>>。因此如果没有使用同一个dataSource，在jdbcTemplate执行sql语句的时候在threadLocal中国呢找不到对应的数据库连接就会重新创建一个，这样autoCommit的默认值为true，这样事务就会失效。
8. 为什么加上了@Configuration注解，事务就不会失效呢。因为加上了@Configuration注解配置类就会变成一个代理对象。又出现了一个问题，在上面不是说spring事务中，如果自己调用自己就会事务失效，调用的是自己原来的方法，方法并没有被增强吗？
   因为Spring事务使用的AOP，他在调用被代理类方法的时候是通过被代理类.method()。这样本质上就是在被代理类中进行的。
   而@Configuration注解配置类并没有使用AOP，而是直接使用了动态代理，他在调用被代理类方法的时候是通过super.method() 这样即使在method中调用另一个method2也是在代理类中进行的。所以method2也是被增强的。这里和aop有着本质的区别。一定要记住aop他像代理对象中增加了一个属性target，并将被代理对象注入进去了，在调用的时候是用的被代理对象。这样做的原因是：代理对象就不用在依赖注入一次，直接将之前依赖注入的对象注入到代理对象中的target属性中。

以上是我对Spring事务失效的理解～