Spring 事务（Transactional）失效的七种原因及解决方案（含项目代码）_网站优化分享

Spring 事务（Transactional）失效的七种原因及解决方案（含项目代码）

简介

“Spring框架提供了强大的事务管理功能，能够确保数据库操作的一致性和可靠性。然而，有时候我们可能会遇到Spring事务失效的情况，导致数据不一致或操作失败。本文将探讨Spring事务失效的原因，以及如何避免和解决这些问题。通过深入了解失效原因，我们可以更好地利用Spring事务管理功能，确保系统的稳定性和可靠性。”

项目搭建

代码仓库URL：https://gitee.com/itwenke/spring-boot-demo/tree/master/transactional

项目截图：

Spring 事务（Transactional）失效的七种原因及解决方案（含项目代码）,在这里插入图片描述,第1张

pom配置


    mysql
    mysql-connector-java


    com.baomidou
    mybatis-plus-boot-starter
    3.5.3.1

数据库配置

spring.datasource.url=jdbc:mysql://localhost:3306/spring-boot-demo?useUnicode=true&characterEncoding=UTF-8&allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

数据表结构

CREATE TABLE `bank_account` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `account` varchar(32) COLLATE utf8mb4_bin NOT NULL COMMENT '账户',
  `balance` bigint NOT NULL COMMENT '余额',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='银行账户';

失效原因

私有方法private

Spring的事务代理通常是通过Java动态代理或CGLIB动态代理生成的，这些代理要求目标方法是公开可访问的（public）。私有方法无法被代理，因此事务将无效。

@Transactional(rollbackFor = Exception.class)
private void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}

直接使用时，这种场景也不太容易出现，因为IDEA会有提醒。

解决方法是将目标方法改为public或protected。

@Transactional(rollbackFor = Exception.class)
public void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}

目标类没有配置为Bean

Spring的事务管理需要在Spring容器中配置的Bean上才能生效。如果目标类没有被配置为Spring Bean，那么事务将无法被应用。

public class NonBeanDemo {
    @Transactional(rollbackFor = Exception.class)
    public void addBankAccount(BankAccount bankAccount) throws Exception {
        IBankAccountService bankAccountService = SpringBeanUtil.getBean(IBankAccountService.class);
        bankAccountService.addBankAccount(bankAccount);
        throw new Exception("测试事务回滚");
    }
}

解决方法是确保目标类被正确配置为Spring Bean。

@Component
public class NonBeanDemo {
    @Transactional(rollbackFor = Exception.class)
    public void addBankAccount(BankAccount bankAccount) throws Exception {
        IBankAccountService bankAccountService = SpringBeanUtil.getBean(IBankAccountService.class);
        bankAccountService.addBankAccount(bankAccount);
        throw new Exception("测试事务回滚");
    }
}

异常不匹配

@Transactional注解默认处理运行时异常，即只有抛出运行时异常，才会触发事务回滚。

@Transactional
public void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}

解决方法是@Transactional设置为@Transactional(rollbackFor = Exception.class)。

@Transactional(rollbackFor = Exception.class)
public void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}

跨越多个线程

如果您的应用程序在多个线程之间共享数据库连接和事务上下文，事务可能会失效，除非适当地配置事务传播属性。

子线程抛异常，主线程正常：

@Transactional(rollbackFor = Exception.class)
public void addBankAccount1() {
    new Thread(() -> {
        BankAccount bankAccount = new BankAccount();
        bankAccount.setAccount("11111111");
        bankAccount.setBalance(10000L);
        bankAccountService.addBankAccount(bankAccount);
    }).start();
    new Thread(() ->{
        BankAccount bankAccount = new BankAccount();
        bankAccount.setAccount("22222222");
        bankAccount.setBalance(10000L);
        bankAccountService.addBankAccount(bankAccount);
        throw new RuntimeException("测试事务回滚");
    }).start();
}

主线程抛异常，子线程正常：

@Transactional(rollbackFor = Exception.class)
public void addBankAccount2() {
    new Thread(() -> {
        BankAccount bankAccount = new BankAccount();
        bankAccount.setAccount("11111111");
        bankAccount.setBalance(10000L);
        bankAccountService.addBankAccount(bankAccount);
    }).start();
    new Thread(() ->{
        BankAccount bankAccount = new BankAccount();
        bankAccount.setAccount("22222222");
        bankAccount.setBalance(10000L);
        bankAccountService.addBankAccount(bankAccount);
    }).start();
    throw new RuntimeException("测试事务回滚");
}

解决方法：参考分布式事务2PC（二阶段提交）方案，2PC是同步阻塞协议，需要等待各个线程执行完成才能进行”提交“还是”回滚”的操作。

Spring 事务（Transactional）失效的七种原因及解决方案（含项目代码）,在这里插入图片描述,第2张

public class MultiThreadingTransactionManager {
    /**
     * 事务管理器
     */
    private final PlatformTransactionManager platformTransactionManager;
    /**
     * 超时时间
     */
    private final long timeout;
    /**
     * 时间单位
     */
    private final TimeUnit unit;
    /**
     * 主线程门闩：当所有的子线程准备完成时，通知主线程判断统一”提交“还是”回滚”
     */
    private final CountDownLatch mainStageLatch = new CountDownLatch(1);
    /**
     * 子线程门闩：count 为0时，说明子线程都已准备完成了
     */
    private CountDownLatch childStageLatch = null;
    /**
     * 是否提交事务
     */
    private final AtomicBoolean isSubmit = new AtomicBoolean(true);
    /**
     * 构造方法
     *
     * @param platformTransactionManager 事务管理器
     * @param timeout 超时时间
     * @param unit 时间单位
     */
    public MultiThreadingTransactionManager(PlatformTransactionManager platformTransactionManager, long timeout, TimeUnit unit) {
        this.platformTransactionManager = platformTransactionManager;
        this.timeout = timeout;
        this.unit = unit;
    }
    /**
     * 任务执行器
     *
     * @param tasks 任务列表
     * @param executorService 线程池
     * @return 是否执行成功
     */
    public boolean execute(List tasks, ThreadPoolTaskExecutor executorService) {
        // 排查null空值
        tasks.removeAll(Collections.singleton(null));
        // 属性初始化
        init(tasks.size());
        for (Runnable task : tasks) {
            // 创建线程
            Thread thread = new Thread(() -> {
                // 判断其它线程是否已经执行任务失败，失败就不执行了
                if (!isSubmit.get()) {
                    childStageLatch.countDown();
                }
                // 开启事务
                DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition();
                TransactionStatus transactionStatus = platformTransactionManager.getTransaction(defaultTransactionDefinition);
                try {
                    // 执行任务
                    task.run();
                } catch (Exception e) {
                    // 任务执行失败，设置回滚
                    isSubmit.set(false);
                }
                // 计数器减一
                childStageLatch.countDown();
                try {
                    // 等待主线程的指示，判断统一”提交“还是”回滚”
                    mainStageLatch.await();
                    if (isSubmit.get()) {
                        // 提交
                        platformTransactionManager.commit(transactionStatus);
                    } else {
                        // 回滚
                        platformTransactionManager.rollback(transactionStatus);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            // 线程池执行任务
            executorService.execute(thread);
        }
        try {
            // 主线程等待所有子线程准备完成，避免死锁，设置超时时间
            childStageLatch.await(timeout, unit);
            long count = childStageLatch.getCount();
            // 主线程等待超时，子线程可能发生长时间阻塞，死锁
            if (count > 0) {
                // 设置回滚
                isSubmit.set(false);
            }
            // 主线程通知子线程”提交“还是”回滚”
            mainStageLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 返回执行结果是否成功
        return isSubmit.get();
    }
    /**
     * 属性初始化
     * @param size 任务数量
     */
    private void init(int size) {
        childStageLatch = new CountDownLatch(size);
    }
}

注意事项1： 2PC是同步阻塞协议，各个任务会等待所有的任务完成准备阶段才能进一步执行，所以在使用中一定要给任务列表提供充足的空闲线程，比如任务列表长度为8，线程池最大线程数不能小于8，否则会使其中的几个任务得不到执行，而其他线程会一直进行等待。即使有一阶段超时处理，事务也始终得不到提交。

注意事项2：如果你的任务是对数据库进行操作，需要考虑数据库连接是否充足，线程等待过程中不会释放数据库连接，如果Connection不够，即使任务被线程池调度执行，也会阻塞在获取数据库连接中，同样会发生“死锁”。

事务传播属性

事务传播属性定义了事务如何传播到嵌套方法或外部方法。如果事务传播属性设置不正确，可能会导致事务失效或不符合预期的行为。

以下是七种事务传播类型：

REQUIRED：如果当前存在事务，则加入该事务，如果当前没有事务，则创建一个新的事务。这是最常用的传播行为，也是默认的，适用于大多数情况。（默认事务：有就加入，没有就新建）
REQUIRES_NEW：无论当前是否存在事务，都创建一个新的事务。如果当前存在事务，则将当前事务挂起。适用于需要独立事务执行的场景，不受外部事务的影响。（独立事务：有没有，都新建）
SUPPORTS：如果当前存在事务，则加入该事务，如果当前没有事务，则以非事务方式执行。适用于不需要强制事务的场景，可以与其他事务方法共享事务。（不强制事务：有就加入，没有就没有）
NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，则将当前事务挂起。适用于不需要事务支持的场景，可以在方法执行期间暂时禁用事务。（非事务：有不加入，没有也不新建）
MANDATORY：如果当前存在事务，则加入该事务，如果当前没有事务，则抛出异常。适用于必须在事务中执行的场景，如果没有事务则会抛出异常。（强制事务：有就加入，没有就抛异常）
NESTED：如果当前存在事务，则在嵌套事务中执行，如果当前没有事务，则创建一个新的事务。嵌套事务是外部事务的一部分，可以独立提交或回滚。适用于需要在嵌套事务中执行的场景。（嵌套事务：有就嵌套，没有就新建）
NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。适用于不允许在事务中执行的场景，如果存在事务则会抛出异常。（强制非事务：没有就没有，有就抛异常）

使用CGLIB动态代理

默认情况下，Spring的事务代理使用基于接口的JDK动态代理。如果您将@Transactional注解声明在接口上，而目标类是使用CGLIB代理的，事务将不会生效。

解决方法是将@Transactional注解移到目标类的方法上，或者配置Spring以使用CGLIB代理接口。

内部类访问

类内部非直接访问带注解标记的方法addBankAccount，而是通过类普通方法 testInnerClass，然后由 testInnerClass 调用 addBankAccount。

@Transactional(rollbackFor = Exception.class)
public void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}
public void testInnerClass(BankAccount bankAccount) throws Exception {
    addBankAccount(bankAccount);
}

解决方法是使用SpringBeanUtil.getBean()获取代理对象。

@Transactional(rollbackFor = Exception.class)
public void addBankAccount(BankAccount bankAccount) throws Exception {
    bankAccountService.addBankAccount(bankAccount);
    throw new Exception("测试事务回滚");
}
public void testInnerClass(BankAccount bankAccount) throws Exception {
    InnerClassDemo innerClassDemo = SpringBeanUtil.getBean(InnerClassDemo.class);
    innerClassDemo.addBankAccount(bankAccount);
}

创建一个网站需要什么网站建设开发文档 ui设计师武汉在线制作网站重庆做网站的科技公司苏州手机模板建站

上一篇：网页版人脸登录，Web端人脸登录，人脸识别，基于Springboot+vue2.X版本+mysql

下一篇：Spring Boot 中使用EasyExcel实现导入导出