【事务】在spring中事务不生效的场景总结

妖狐艹你老母 2023-10-09 21:36 67阅读 0赞

在开发过程中会遇到事务失效的问题，所以在开发中要特别注意，下面我自己总结了事务不生效的场景，提醒自己。  
一般出现问题分为几大类：

*  配置问题
 *  spring aop代理问题
 *  底层数据库不支持事务问题
 *  @Transactional 配置错误
 *  开发过程中使用错误问题

## 1.配置问题 ##

### 1. 你的service类没有被Spring管理 ###

//@Service 
    public class TransactionalUserServiceImpl implements TransactionalUserService {
        
    
        @Resource
        TransactionalUserMapper transactionalUserMapper;
    
        @Override
        @Transactional
        public void transactionalError() throws Exception {
        
            TransactionalUser transactionalUser = new TransactionalUser();
            transactionalUser.setAsMsg("测试事务失效，修改成功");
            transactionalUser.setId("1");
            transactionalUserMapper.updateById(transactionalUser);
            throw new Exception();
        }
     }

*  失败原因：@Service注解注释之后，spring事务（@Transactional）没有生效，因为Spring事务是由AOP机制实现的，也就是说从Spring IOC容器获取bean时，Spring会为目标类创建代理，来支持事务的。但是@Service被注释后，你的service类都不是spring管理的，所以无法创建代理。
 *  解决方法：加上@service注解，但是一般不会犯这种错误。

### 2. 没有开启事务管理器 ###

*  单独使用@Transactional，其实是不会生效的，因为它需要配置事务管理器开启事务。
 *  解决方法：springboot项目启动类要加入：@EnableTransactionManagement ，当然新版本它默认会自动配置事务管理器并开启事务支持。

## 2.spring aop代理问题 ##

### 1.方法被final、static关键字修饰 ###

@Transactional
        public final void add(Addreq req) {
        
             //保存实体数据库记录
            addMapper.save(req);
            //保存流水数据库记录
            addFlowMapper.saveFlow(buildFlowById(req));
        }

*  原因 ：如果一个方法被声明为final或者static，则该方法不能被子类重写，也就是说无法在该方法上进行动态代理，这会导致Spring无法生成事务代理对象来管理事务。
 *  解决方法 ：add事务方法 不要用final修饰或者static修饰。

### 2.同一个类中，方法内部调用 ###

@Override
        public void transactionalErrorV4() {
        
            this.transactionalUser();
        }
    
        @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
        public void transactionalUser() {
        
            TransactionalUser transactionalUser = new TransactionalUser();
            transactionalUser.setAsMsg("测试事务失效");
            transactionalUser.setId("2");
            transactionalUserMapper.updateById(transactionalUser);
        }

*  原因 : 事务是通过Spring AOP代理来实现的，而在同一个类中，一个方法调用另一个方法时，调用方法直接调用目标方法的代码，而不是通过代理类进行调用 。即以上代码，调用目标transactionalUser方法不是通过代理类进行的，因此事务不生效。
 *  解决方法 ：
    
     *  可以新建多一个类，让这两个方法分开，分别在不同的类中。
     *  也可以把主方法加上@Transactional，使他们用一个事务

### 3.方法的访问权限不是public ###

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      private void transactionalUser() {
        
           TransactionalUser transactionalUser = new TransactionalUser();
           transactionalUser.setAsMsg("测试事务失效");
           transactionalUser.setId("2");
           transactionalUserMapper.updateById(transactionalUser);
       }

*  原因 ：spring事务方法transactionalUser的访问权限不是public，所以事务就不生效啦，因为Spring事务是由AOP机制实现的，AOP机制的本质就是动态代理，而代理的事务方法不是public的话，computeTransactionAttribute()就会返回null，也就是这时事务属性不存在了。大家可以看下AbstractFallbackTransactionAttributeSource的源码
 *  ![在这里插入图片描述][7f67f06e2f2a4efebdb2ba35e1146130.png]

## 3.底层数据库不支持事务问题 ##

Spring事务的底层，还是依赖于数据库本身的事务支持。在MySQL中，MyISAM存储引擎是不支持事务的，InnoDB引擎才支持事务。因此开发阶段设计表的时候，确认你的选择的存储引擎是支持事务的 。

## 4.@Transactional 配置错误 ##

### 1.配置成只读事务 ###

@Transactional(readOnly = true)
    public void updateUser(User user) {
        
        userDao.updateUser(user);
    }

*  原因 ：虽然使用了@Transactional注解，但是注解中的readOnly=true属性指示这是一个只读事务，因此在更新User实体时会抛出异常。
 *  解决方法：将readOnly属性设置为false，或者移除了@Transactional注解中的readOnly属性。

### 2.事务超时时间设置过短 ###

@Transactional(timeout = 1)
    public void doSomething() {
        
    }

*  原因 ：在上面的例子中，timeout属性被设置为1秒，这意味着如果事务在1 秒内无法完成，则报事务超时了。

### 3.使用了错误的事务传播机制 ###

//以非事务方式执行操作，如果当前存在一个事务，则将该事务挂起。
    @Transactional(propagation = Propagation.NOT_SUPPORTED)

这里要科普下Spring提供了七种事务传播机制：

1.  **REQUIRED（默认）：如果当前存在一个事务，则加入该事务；否则，创建一个新事务。该传播级别表示方法必须在事务中执行。**
2.  SUPPORTS：如果当前存在一个事务，则加入该事务；否则，以非事务的方式继续执行。
3.  MANDATORY：如果当前存在一个事务，则加入该事务；否则，抛出异常。
4.  REQUIRES\_NEW：创建一个新的事务，并且如果存在一个事务，则将该事务挂起。
5.  NOT\_SUPPORTED：以非事务方式执行操作，如果当前存在一个事务，则将该事务挂起。
6.  NEVER：以非事务方式执行操作，如果当前存在一个事务，则抛出异常。
7.  NESTED：如果当前存在一个事务，则在嵌套事务内执行。如果没有事务，则按REQUIRED传播级别执行。嵌套事务是外部事务的一部分，可以在外部事务提交或回滚时部分提交或回滚。

### 4.rollbackFor属性配置错误 ###

@Override
        @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Error.class)
        public void transactionalErrorV6() throws Exception {
        
            TransactionalUser transactionalUser = new TransactionalUser();
            transactionalUser.setAsMsg("测试事务失效");
            transactionalUser.setId("3");
            transactionalUserMapper.updateById(transactionalUser);
            throw new Exception();
        }

*  原因 : 其实rollbackFor属性指定的异常必须是Throwable或者其子类。默认情况下，Exception和Error两种异常都是会自动回滚的。但是因为以上的代码例子，指定了rollbackFor = Error.class，但是抛出的异常又是Exception，因此事务就不生效。
 *  解决方法：要rollbackFor属性指定的异常与抛出的异常匹配。

## 5.使用不当 ##

### 1.事务注解被覆盖导致事务失效 ###

public interface A{
        
        @Transactional
        void save(String data);
    }
    
    public class AImpl implements A{
        
        @Override
        public void save(String data) {
        
            // 数据库操作
        }
    }
    
    public class BService {
        
    
        @Autowired
        private A A;
    
        @Transactional
        public void doSomething(String data) {
        
            A.save(data);
        }
    }
    
    public class CService extends BService {
        
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void doSomething(String data) {
        
            super.doSomething(data);
        }
    }

*  原因 ：
    
     *  CService 是 BService 的子类，并且覆盖了doSomething()方法。
     *  在该方法中，使用了不同的传播行为（REQUIRES\_NEW）来覆盖父类的@Transactional注解。
     *  在这种情况下，当调用CService 的doSomething()方法时，由于子类方法中的注解覆盖了父类的注解，Spring框架将不会在父类的方法中启动事务 。
     *  因此，当A类的save()方法被调用时，事务将不会被启动，也不会回滚。
     *  这将导致数据不一致的问题，因为在A的save()方法中进行的数据库操作将不会回滚。
 *  解决：一般不建议业务调用链路太深，出现问题也不好排查。

### 2.嵌套事务 ###

在开发中我们会执行两个及其以上的保存操作，有时候我们不需要全部回滚，但是如果没有特殊处理，出现问题都会回滚。

@Service
    public class AService {
        
    
        @Autowired
        private BService bService;
        @Autowired
        private AMapper aMapper ;
    
        @Transactional
        public void addOrder(Order order) throws Exception {
        
            aMapper.save(order);
            bService.saveFlow(order);
        }
    }
    
    @Service
    public class BService {
        
    
        @Autowired
        private BMapper bMapper;
    
        @Transactional(propagation = Propagation.NESTED)
        public void saveFlow(Order order) {
        
            bMapper.save(order);
            throw new RuntimeException();
        }
    }

*  原因：以上代码使用了嵌套事务，如果saveFlow出现运行时异常，会继续往上抛，到外层addOrder的方法，导致 aMapper.save(order);也会回滚。
 *  解决方法：如果不想因为被内部嵌套的事务影响 ，可以用try-catch包住，如下：

@Transactional
      public void addOrder(Order order) throws Exception {
        
         aMapper.save(order);
          try {
        
              bService.saveFlow(order);
          } catch (Exception e) {
        
            log.error("savefail,message:{}",e.getMessage());
          }
      }

### 3.事务多线程调用 ###

@Override
        @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
        public void transactionalAsV11()  {
        
            new Thread(() -> {
        
                try {
        
                    transactionalUser();
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }).start();
        }
    
        public void transactionalUser() throws Exception {
        
            TransactionalUser transactionalUser = new TransactionalUser();
            transactionalUser.setAsMsg("测试事务失效");
            transactionalUser.setId("2");
            transactionalUserMapper.updateById(transactionalUser);
            throw new Exception();
        }

*  原因 ：这是因为Spring事务是基于线程绑定的，每个线程都有自己的事务上下文 ，而多线程环境下可能会存在多个线程共享同一个事务上下文的情况，导致事务不生效。Spring事务管理器通过使用线程本地变量（ThreadLocal）来实现线程安全。
 *  解决方法：通过TransactionAspectSupport 来手动设置回滚

public void transactionalUser() throws Exception {
        
            //设置回滚点,只回滚以下异常
            Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
            try {
        
                TransactionalUser transactionalUser = new TransactionalUser();
                transactionalUser.setAsMsg("测试事务失效");
                transactionalUser.setId("2");
                transactionalUserMapper.updateById(transactionalUser);
                throw new Exception();
            } catch (Exception e) {
        
                TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            }
        }

还有一种方式是使用springboot的线程注解： @Async

@Override
        @Async("MyExecutor")
        @Transactional(propagation = Propagation.REQUIRED, rollbackFor = RuntimeException.class)
        public void transactionalAsV12() throws InterruptedException {
        
            Thread.sleep(10000);
            TransactionalUser transactionalUser = new TransactionalUser();
            transactionalUser.setAsMsg("测试事务失效");
            transactionalUser.setId("2");
            transactionalUserMapper.updateById(transactionalUser);
            throw new RuntimeException();
        }

上面写法事务是生效的，但是使用注解有几个注意点需要注意一下：  
如下方式会使@Async失效

*  异步方法使用static修饰
 *  异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
 *  异步方法不能与被调用的异步方法在同一个类中
 *  类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
 *  如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解

### 4.异常没有抛出 ###

@Transactional
      public void addOrder(Order order) {
        
           try {
           
               aMapper.save(order);
               bFlowMapper.saveFlow(order);
           } catch (Exception e) {
        
               log.error("add error,id:{},message:{}", order.getId(),e.getMessage());
           }
       }

*  原因 : 事务中的异常已经被业务代码捕获并处理，而没有被正确地传播回事务管理器，事务将无法回滚。我们可以从spring源码(TransactionAspectSupport这个类)中找到答案：  
    ![在这里插入图片描述][9d0310fc531c4257840ac8ef53880903.png]在invokeWithinTransaction方法中，当Spring catch到Throwable异常的时候，就会调用completeTransactionAfterThrowing()方法进行事务回滚的逻辑。但是，在addOrder 事务方法中，直接把异常catch住了，并没有重新throw出来，因此 Spring自然就catch不到异常，因此事务回滚的逻辑就不会执行，事务就失效了。

解决方法：抛出异常就好了

@Override
        @Transactional(propagation = Propagation.REQUIRED, rollbackFor = RuntimeException.class)
        public void transactionalAsV13() {
        
            try {
        
                TransactionalUser transactionalUser = new TransactionalUser();
                transactionalUser.setAsMsg("测试事务失效");
                transactionalUser.setId("2");
                transactionalUserMapper.updateById(transactionalUser);
                throw new RuntimeException();
            } catch (RuntimeException e) {
        
                System.out.println("吞并异常");
                throw new RuntimeException();
            }
        }

[7f67f06e2f2a4efebdb2ba35e1146130.png]: https://img-blog.csdnimg.cn/7f67f06e2f2a4efebdb2ba35e1146130.png
[9d0310fc531c4257840ac8ef53880903.png]: https://img-blog.csdnimg.cn/9d0310fc531c4257840ac8ef53880903.png