Spring事务 - Spring事务失效的场景

Spring事务失效的场景

   概要

   说到Spring事务，大家可能都会想到@Transactional注解，但是很多人只是停留在基础的使用层面上，在遇到一些比较特殊的场景，事务可能没有生效，直接在生产上暴露了，这可能就会导致比较严重的生产事故。今天，我们就简单来说下Spring事务的原理，然后总结一下spring事务失败的场景，并提出对应的解决方案。

   一、Spring事务原理

   JDBC中操作事务的伪代码如下： 

//Get database connection
Connection connection = DriverManager.getConnection();
//Set autoCommit is false
connection.setAutoCommit(false);
//use sql to operate database
.........
//Commit or rollback
connection.commit()/connection.rollback

connection.close();     

   需要在各个业务代码中编写代码如commit()、close()来控制事务。

   但是Spring不乐意这么干了，这样对业务代码侵入性太大了，所有就用一个事务注解@Transactional来控制事务，底层实现是基于切面编程AOP实现的，而Spring中实现AOP机制采用的是动态代理，具体分为JDK动态代理和CGLIB动态代理两种模式。

   1. Spring的bean的初始化过程中，发现方法有@Transactional注解，就需要对相应的Bean进行代理，生成代理对象。

   2. 然后在方法调用的时候，会执行切面的逻辑，而这里切面的逻辑中就包含了开启事务、提交事务或者回滚事务等逻辑。

   注意：Spring 本身不实现事务，底层还是依赖于数据库的事务。没有数据库事务的支持，Spring事务是不会生效的。

   二、事务失效场景

   有时候，我们明明在类或者方法上添加了@Transactional注解，却发现方法并没有按事务处理。其实，以下场景会导致事务失效。整理如下图：

 

   三、Spring框架配置问题

   1. 没有被Spring管理

// @Service
public class OrderServiceImpl implements OrderService {
    @Transactional
    public void updateOrder(Order order) {
        // update order
    }
}

   Spring声明式事务的实现完全依赖于Spring的AOP代理机制，未被Spring管理的类中的方法不受Spring的AOP代理管理，因此，声明式事务失效。

   这里将@Service 注解注释掉，这个类就不会被加载成一个 Bean，那这个类就不会被 Spring 管理了，事务自然就失效了。

   事务不生效原因：

   @Service注解注释之后， Spring事务（ @Transactional）没有生效，是因为 Spring事务是由 AOP机制实现的，也就是说从 Spring IOC容器获取 bean时， Spring会为目标类创建代理，来支持事务的。但是 @Service被注释后，这个service类都不是 spring管理的， 那怎么创建代理类来支持事务呢。

   解决方案:

   需要保证每个事务注解的每个Bean被Spring管理。

   2.  没有在Spring配置文件中启用事务管理器

@Configuration
public class AppConfig {
    // 没有配置事务管理器
}

@Service
public class MyService {
    @Transactional
    public void doSomething() {
        // ...
    }
}

   事务不生效原因：

   如果没有配置事务管理器或未启用事务管理，使用 @Transactional 注解时，Spring 将不会对方法进行事务处理，导致事务失效。事务管理器负责创建、提交和回滚事务，是实现事务控制的核心组件。

   解决方案：

   在 AppConfig中配置一个事务管器并且启用事务管理器

@Configuration
@EnableTransactionManagement
public class AppConfig {
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

@Service
public class MyService {
    @Transactional
    public void doSomething() {
        // ...
    }
}

   说明：如果是Spring Boot项目，它默认会自动配置事务管理器并开启事务支持。

   四、Spring AOP代理问题

   1.  方法使用 final 或 static关键字

@Service
public class TianLuoServiceImpl  {

    @Transactional
    public final void addTianLuo(TianLuo tianluo) {
       //...
    }
}

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

   具体来说：

   1）如果Spring使用了Cglib代理实现（比如你的代理类没有实现接口），而你的业务方法恰好使用了final或者static关键字，那么事务也会失败。更具体地说，它应该抛出异常，因为Cglib使用字节码增强技术生成被代理类的子类并重写被代理类的方法来实现代理。如果被代理的方法的方法使用final或static关键字，则子类不能重写被代理的方法。

   2）如果Spring使用JDK动态代理实现，JDK动态代理是基于接口实现的，那么final和static修饰的方法也就无法被代理。

   总而言之，方法连代理都没有，那么肯定无法实现事务回滚了。

   解决方案： addTianLuo 事务方法不要用 final修饰或者 static修饰。

   2.  方法没有被public修饰

   @Transactional注解只能作用于public修饰的方法上

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Transactional
    private void addTianLuo(TianLuo tianluo) {
        tianLuoMapper.save(tianluo);
    }
}

    事务失效原因：Spring AOP 代理时，TransactionInterceptor （事务拦截器）在目标方法执行前后进行拦截，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource的 computeTransactionAttribute 方法，获取Transactional 注解的事务配置信息。

protected TransactionAttribute computeTransactionAttribute(Method method,
    Class<?> targetClass) {
        // Don't allow no-public methods as required.
        if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
        return null;
}

    此方法会检查目标方法的修饰符是否为 public，不是 public 则不会获取@Transactional 的属性配置信息。

   注意：protected、private 修饰的方法上使用 @Transactional 注解，虽然事务无效，但不会有任何报错。

   解决方案：将当前方法访问级别更改为public。

   3.  在同一个类中的方法调用

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    public void A() {
        B();
    }

    @Transactional
    public void B() {
        userMapper.deleteById(1);
        int i = 10 / 0; //模拟发生异常
    }
    
}

   事务失效原因：像上面的代码，B方法使用@Transactional注解标注，在A方法中调用了B方法，在外部调用A方法时，B方法的事务不会生效。这是由于使用Spring AOP代理造成的，因为只有当事务方法被当前类以外的代码调用时，才会由Spring生成的代理对象来管理。

   那么如果确实在同一类中调用事务方法怎么办呢？有以下3种方法解决：

   1） 引入自身bean

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    @Autowired
    UserServiceImpl userServiceImpl;

    public void A() {
        userServiceImpl.B();
    }

    @Transactional
    public void B() {
        userMapper.deleteById(1);
        int i = 10 / 0; //模拟发生异常
    }

}

   2） 通过ApplicationContext引入bean

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    @Autowired
    ApplicationContext applicationContext;

    public void A() {
        ((UserServiceImpl) applicationContext.getBean("userServiceImpl")).B();
    }

    @Transactional
    public void B() {
        userMapper.deleteById(1);
        int i = 10 / 0; //模拟发生异常
    }

}

   3）通过AopContext获取当前代理类

   在启动类上添加注解@EnableAspectJAutoProxy(exposeProxy = true)，表示是否对外暴露代理对象，即是否可以获取AopContext。然后，在业务类上使用AopContext。

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    public void A() {
        ((UserServiceImpl) AopContext.currentProxy()).B();
    }

    @Transactional
    public void B() {
        userMapper.deleteById(1);
        int i = 10 / 0; //模拟发生异常
    }

}

  五、底层数据库不支持

  1.  数据库的存储引擎不支持事务

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

  六、Transactional配置问题

  1.  配置错误的@Transactional注解

@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.  错误使用事务传播机制

  Spring事务的传播机制是指在多个事务方法相互调用时，确定事务应该如何传播的策略。Spring提供了七种事务传播机制：REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED。如果不知道这些传播策略的原理，很可能会导致操作失败。详细请参考文章《Spring事务 - 事务传播机制》

  如果我们在手动设置propagation参数的时候，把传播特性设置错了，比如：

@Service
public class OrderServiceImpl {

    @Transactional(propagation = Propagation.NEVER)
    public void cancelOrder(UserModel userModel) {
        // 取消订单
        cancelOrder(orderDTO);
        // 还原库存
        restoreProductStock(orderDTO.getProductId(), orderDTO.getProductCount());
    }
}

   我们可以看到cancelOrder()方法的事务传播特性定义成了Propagation.NEVER，这种类型的传播特性不支持事务，如果有事务则会抛异常。

   解决方案：选择正确的事务传播机制。

   4.  rollbackFor属性配置错误

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Transactional(rollbackFor = Error.class)
    public void addTianLuo(TianLuo tianluo) {
        //...
        throw new Exception();
    }
}

   事务不生效的原因:

   其实 rollbackFor属性指定的异常必须是 Throwable或者其子类。默认情况下， RuntimeException和 Error两种异常都是会自动回滚的。但是因为以上的代码例子，指定了 rollbackFor = Error.class，但是抛出的异常又是 Exception，而 Exception和Error没有任何什么继承关系，因此事务就不生效。

   如下图：

   解决方案： rollbackFor 属性指定的异常与抛出的异常匹配。

   七、开发使用不当

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

public interface MyRepository {
    @Transactional
    void save(String data);
}

public class MyRepositoryImpl implements MyRepository {
    @Override
    public void save(String data) {
        // 数据库操作
    }
}

public class MyService {

    @Autowired
    private MyRepository myRepository;

    @Transactional
    public void doSomething(String data) {
        myRepository.save(data);
    }
}

public class MyTianluoService extends MyService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomething(String data) {
        super.doSomething(data);
    }
}

   事务失效的原因：

   在 MyTianluoService 中重写 doSomething() 方法并使用 REQUIRES_NEW 传播行为时，会创建一个新事务。在调用 super.doSomething(data) 时，父类的事务被挂起，MyRepository.save(data) 在新事务中执行。因此，这可能导致数据不一致，因为如果新事务回滚，父类的操作不会回滚。

   2. 嵌套事务的坑

@Service
public class TianLuoServiceInOutService {

    @Autowired
    private TianLuoFlowService tianLuoFlowService;
    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        tianLuoMapper.save(tianluo);
        tianLuoFlowService.saveFlow(tianluo);
    }
}

@Service
public class TianLuoFlowService {

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional(propagation = Propagation.NESTED)
    public void saveFlow(TianLuo tianLuo) {
        tianLuoFlowMapper.save(tianLuo);
        throw new RuntimeException();
    }
}

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

@Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        tianLuoMapper.save(tianluo);
        try {
            tianLuoFlowService.saveFlow(tianluo);
        } catch (Exception e) {
          log.error("save tian luo flow fail,message:{}",e.getMessage());
        }
    }

   3. 事务多线程调用

@Service
public class TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Autowired
    private TianLuoFlowService tianLuoFlowService;

    @Transactional
    public void addTianLuo(TianLuo tianluo) {
        //保存tianluo数据库记录
        tianLuoMapper.save(tianluo);
        //多线程调用
        new Thread(() -> {
            tianLuoFlowService.saveFlow(tianluo);
        }).start();
    }
}

@Service
public class TianLuoFlowService {

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void save(TianLuo tianLuo) {
        tianLuoFlowMapper.saveFlow(tianLuo);
    }
}

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

    分析： 在Spring事务管理器中，通过TransactionSynchronizationManager类来管理事务上下文。TransactionSynchronizationManager内部维护了一个ThreadLocal对象，用来存储当前线程的事务上下文。在事务开始时，TransactionSynchronizationManager会将事务上下文绑定到当前线程的ThreadLocal对象中，当事务结束时，TransactionSynchronizationManager会将事务上下文从ThreadLocal对象中移除。

部分源码如下：

public class TransactionSynchronizationManager {

    // 使用 ThreadLocal 来存储每个线程的事务上下文
    private static final ThreadLocal<TransactionalResourceHolder> resourceHolder =
            new ThreadLocal<>();

    // 绑定事务资源到当前线程
    public static void bindResource(Object resource) {
        // 创建一个新的 TransactionalResourceHolder，并将其绑定到当前线程
        resourceHolder.set(new TransactionalResourceHolder(resource));
    }

    // 从当前线程中解绑事务资源
    public static Object unbindResource() {
        // 获取当前线程绑定的 TransactionalResourceHolder
        TransactionalResourceHolder holder = resourceHolder.get();
        if (holder != null) {
            // 获取资源
            Object resource = holder.getResource();
            // 清除当前线程的资源绑定
            resourceHolder.remove(); // 清除资源
            return resource; // 返回解绑的资源
        }
        return null; // 如果没有绑定的资源，则返回 null
    }

    // 检查当前线程是否有活跃的事务
    public static boolean isActualTransactionActive() {
        // 如果当前线程的 ThreadLocal 中存在资源，说明有活跃的事务
        return resourceHolder.get() != null;
    }
}

   解决方案：尽量还是保证在同一个事务中处理。

   4. 业务方法本身捕获了异常

@Transactional(rollbackFor = Exception.class)
public void transactionTest() {
    try {
        User user = new User();
        UserService.insert(user);
        int i = 1 / 0;
    }catch (Exception e) {
        e.printStackTrace();
    }
}

    事务不生效的原因:

    事务中的异常已经被业务代码捕获并处理，而没有被正确地传播回事务管理器，事务将无法回滚。我们可以从 spring源码( TransactionAspectSupport这个类)中找到答案：

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {

 //这方法会省略部分代码，只留关键代码哈
  @Nullable
 protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable {

  if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
  
   TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
   Object retVal;
   try {
    //Spring AOP中MethodInterceptor接口的一个方法，它允许拦截器在执行被代理方法之前和之后执行额外的逻辑。
    retVal = invocation.proceedWithInvocation();
   }
   catch (Throwable ex) {
    //用于在发生异常时完成事务(如果Spring catch不到对应的异常的话，就不会进入回滚事务的逻辑)
    completeTransactionAfterThrowing(txInfo, ex);
    throw ex;
   }
   finally {
    cleanupTransactionInfo(txInfo);
   }

   //用于在方法正常返回后提交事务。
   commitTransactionAfterReturning(txInfo);
   return retVal;
  }
}

   分析：在invokeWithinTransaction方法中，当Spring catch到Throwable异常的时候，就会调用completeTransactionAfterThrowing()方法进行事务回滚的逻辑。但是，在TianLuoServiceImpl类的spring事务方法addTianLuo中，直接把异常catch住了，并没有重新throw出来，因此 Spring自然就catch不到异常啦，因此事务回滚的逻辑就不会执行，事务就失效了。

   解决方案：

   在 spring事务方法中，当我们使用了 try-catch，如果catch住异常，记录完异常日志什么的，一定要重新把异常抛出来，如下：

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional(rollbackFor = Exception.class)
    public void addTianLuo(TianLuo tianluo) {
        try {
            //保存tianluo数据库记录
            tianLuoMapper.save(tianluo);
            //保存tianluo flow数据库记录
            tianLuoFlowMapper.saveFlow(tianluo);
        } catch (Exception e) {
            log.error("add TianLuo error,id:{},message:{}", tianluo.getId(),e.getMessage());
            throw e;
        }
    }
}

   5.  手动抛了别的异常

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        //保存tianluo数据库记录
        tianLuoMapper.save(tianluo);
        //保存tianluo流水数据库记录
        tianLuoFlowMapper.saveFlow(tianluo);
        throw new Exception();
    }
}

   失效的原因：上面的代码例子中，手动抛了 Exception异常，但是是不会回滚的，因为Spring默认只处理 RuntimeException和Error，对于普通的 Exception不会回滚，除非，用 rollbackFor属性指定配置。
   解决方案：添加属性配置 @Transactional(rollbackFor = Exception.class)。

   参考链接:

   https://juejin.cn/post/7179080622504149029

   https://heapdump.cn/article/5542790