springBoot 声明式事务，设置声明式事务的隔离级别，先事务 + 后加锁出现的异常

于 2024-01-28 00:21:03 发布
阅读量940 收藏 22
点赞数 20
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45737675/article/details/135890741
版权
本文详细介绍了SpringBoot中声明式事务的使用，特别是TransactionTemplate的几种传播行为（如propagation_required、propagation_supports等），以及如何处理事务隔离级别，以确保多线程和嵌套事务的正确性。
摘要由CSDN通过智能技术生成

springBoot 声明式事务，设置声明式事务的隔离级别

之前使用的是 @Transactional 最近迷上 声明式事务了 TransactionTemplate

  1. propagation_required：spring的默认传播机制，如果上下文有事物则加入当前事务，如果不存在事物则新建事物执行。

  2. propagation_supports：如果上下文中存在事务则加入当前事务，如果没有则以非事务的方式运行。

  3. propagation_mandatory：该传播级别要求上下文必须存在事务，否者抛出异常。

  4. propagation_requires_new：该传播级别每次都会创建新的事物，并同时将上下文中的事务挂起，新事物执行完成后，会恢复上下文事物。（外层的事务不会影响内层的事务提交和回滚）

  5. propagation_not_supported：如果上下文存在事物则挂起当前事物，并以非事物的方式执行当前逻辑，执行完成后恢复上下文事物

  6. propagation_never：该传播级别要求上下文中不能存在事务，否则抛出异常

  7. propagation_nested：嵌套事务，如果上下文中存在事务则嵌套执行，不存在则新建事物 （save point 概念）（外层事务会影响内层的事务提交和回滚）

说一下用的最多的两个传播机制

propagation_required（默认传播机制）

package com.app.service;

import com.app.entity.Test;
import com.app.mapper.TestMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;

/**
 * @author supermarketss@163.com
 * @date 2024-01-19 - 14:08
 */
@Service
public class TestService1 {
    @Autowired
    private TestMapper testMapper;


    /**
     * 这里的@Lazy主要解决循环依赖的问题
     */
    @Autowired
    @Lazy
    private TestService1 thisService;

    @Autowired
    private PlatformTransactionManager transactionManager;


    public void a() {
        TransactionTemplate transaction = new TransactionTemplate(transactionManager);
        transaction.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

        transaction.execute(status -> {
            Test test = new Test();
            test.setId(1);
            test.setName("张三");
            testMapper.insert(test);
            //默认，如果方法没有事务则加入当前事务
            thisService.b();
            return null;
        });
    }

    public void b() {
        Test test = new Test();
        test.setId(2);
        test.setName("王五");
        testMapper.insert(test);
        int a = 1 / 0;
    }
}

这种情况下b方法出现异常，a方法也会一块回滚的

propagation_requires_new（创建新的事务挂起当前事务）

package com.app.service;

import cn.hutool.extra.spring.SpringUtil;
import com.app.entity.Test;
import com.app.mapper.TestMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;

/**
 * @author supermarketss@163.com
 * @date 2024-01-27 - 22:24
 */
@Service
public class TestService2 implements ApplicationRunner {

    @Autowired
    private TestMapper testMapper;


    @Autowired
    private PlatformTransactionManager transactionManager;


    //spring启动完成后执行
    @Override
    public void run(ApplicationArguments args) throws Exception {

        TransactionTemplate transaction = new TransactionTemplate(transactionManager);
        transaction.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        transaction.execute(status -> {
            SpringUtil.getBean(TestService2.class).b();

            Test test = new Test();
            test.setId(1);
            test.setName("张三");
            testMapper.insert(test);

            int a = 1 / 0;
            return null;
        });
    }

    public void b() {
        //PROPAGATION_REQUIRES_NEW 如果上下文有事务会暂时挂起，并且开启一个新的事务执行，独立于原来的事务
        //所以，即使a方法出现异常，b方法也不会回滚
        TransactionTemplate transaction = new TransactionTemplate(transactionManager);
        transaction.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        transaction.execute(status -> {

            Test test = new Test();
            test.setId(2);
            test.setName("王五");
            testMapper.insert(test);

            return null;
        });
    }
}

外层事务不会影响，内层的事务提交与回滚的

@Transactional 多线程事务异常

这里需要在说一下mysql的事务隔离级别了 可重复读：开启事务后，即使其他事务数据已经提交了，原本的事务读取到的还是原来的数据。

问题复现 (先事务+后加锁 )

package com.app.service;

import cn.hutool.extra.spring.SpringUtil;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.concurrent.TimeUnit;

/**
 * @author supermarketss@163.com
 * @date 2024-01-27 - 22:24
 */
@Service
public class TestService3 implements ApplicationRunner {
    @Autowired
    private RedissonClient redissonClient;

    //spring启动完成后执行
    @Override
    public void run(ApplicationArguments args) throws Exception {
        for (int i = 0; i < 50; i++) {
            new Thread(() ->{
                SpringUtil.getBean(TestService3.class).b();
            }).start();
        }
    }

    @Transactional
    public void b() {
        RLock lock = redissonClient.getLock("test:sub:lock");
        lock.lock(30, TimeUnit.SECONDS);
        try {
            //获取库存

            //扣减库存
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

因为先开启的事务，后添加的锁，在多线程的情况下，一个线程进入开启事务并抢到锁，并开始执行扣库存的逻辑，第二个线程也进来，开启事务，但是锁被其他线程拿到需要等待，此时就出现问题了。第二个线程因为已经开启事务，即使第一个线程提交第二个线程拿到的也是原来的数据（mysql模式隔离级别，可重复读）

解决问题（先加锁 + 后加事务）

package com.app.service;

import cn.hutool.extra.spring.SpringUtil;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

import java.util.concurrent.TimeUnit;

/**
 * @author supermarketss@163.com
 * @date 2024-01-27 - 22:24
 */
@Service
public class TestService4 implements ApplicationRunner {
    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private TransactionTemplate transactionTemplate;


    //spring启动完成后执行
    @Override
    public void run(ApplicationArguments args) throws Exception {
        for (int i = 0; i < 50; i++) {
            new Thread(() -> {
                SpringUtil.getBean(TestService4.class).b();
            }).start();
        }
    }

    public void b() {
        RLock lock = redissonClient.getLock("test:sub:lock");
        lock.lock(30, TimeUnit.SECONDS);
        try {
            transactionTemplate.execute(status -> {
                //获取库存

                //扣减库存
                return null;
            });
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

在多线程的情况下，线程1先加锁，在开启事务，在执行业务逻辑，此时第二个线程到来，因为第一个线程已经获取到锁，第二个线程需要等待，等待第一个线程整个业务逻辑执行完成并提交后，第二个线程才能拿到锁

demo地址

参考

原创 | CRUD更要知道的Spring事务传播机制 (qq.com)

Spring的嵌套事务(Propagation.NESTED)到底是个啥 - 掘金 (juejin.cn)

事务之保存点（savepoint）-CSDN博客

事务+锁，锁+事务，解析事务与锁的错综Bug (qq.com)

@Lazy注解解决循环依赖原理 - 知乎 (zhihu.com)

梦想是条大咸鱼
关注
  • 20
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot隔离级别
qq_40662354的博客
06-27 340
springboot的默认隔离级别，使用数据库默认的隔离级别。注意：并发引起脏数据，锁加到事务外面，具体例子见下面第二个链接。在Spring Boot中，事务的隔离级别可以通过。SpringBoot的隔离级别有五种值，但。：避免脏读，但允许不可重复读和幻读。：避免脏读和不可重复读，但允许幻读。数据库有不同的下四种类型之一，所以说。：允许脏读、不可重复读和幻读。：避免以上所有并发问题。
【Spring Boot】事务的隔离级别与事务的传播特性详解：如何在 Spring 中使用事务？不同隔离级别的区别？
黄小黄的博客
07-22 3857
事务这个词在学习 MySQL 和多线程并发编程的时候，想必大家或多或少接触过。那么什么是事务呢？事务是指一组操作作为一个不可分割的执行单元，要么全部成功执行，要么全部失败回滚。在数据库中，事务可以保证数据的一致性、完整性和稳定性，同时避免了数据的异常和不一致情况。常见的事务包括插入、更新、删除等数据库操作。事务的核心要素是ACID特性，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。本文从事务及隔离级别以及事务传播机制分别讲解。
@Transactional和锁导致的问题
最新发布
weixin_41979002的博客
11-01 355
坑：使用@Transactional注解开启事务管理，假如线程一调用addEmployee获取锁调用addEmployee（）方法之后但这时还未提交事务，数据库中id =8 该条记录还未有做更新，线程一释放锁，线程二获取到锁调用完方法之后和线程一恰好一起提交事务，此时可能会造成数据库表被锁（或死锁），出现异常之后由于使用@Transactional事务会造成线程一和线程二都没有修改到数据库记录。注意：无论是使用synchronized 作锁或是使用redis作锁都会有可能这种情况发生，在事务中使用锁无效！
springboot的事务的隔离级别与操作案例
健康平安的活着的专栏
03-07 3567
一.事务的隔离级别 二.事务的案例 2.1 正常的逻辑添加 2.2设置报错逻辑添加 程序报错后，还是执行了新增数据操作，并不是我们期望的。 2.3设置事务报错逻辑添加 添加事务：@Transactional(propagation=Propagation.REQUIRED) 不停的刷新，数据库，可以看到，报错后，进行事务的控制，不再进行新增加数据了！！ ...
Springboot分布式事务
lovoo的博客
06-19 4544
本地事务是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器位于同一节点相同数据库上。又称为传统事务。它是一个操作序列，这些操作要么都执行，要么都不执行，是一个不可分割的工作单位。例如，银行转账工作：从一个帐号扣款并使另一个帐号增款，这两个操作要么都执行，要么都不执行。数据库事务必须具备ACID特性，即原子性、一致性、隔离性和持久性。CAP定理，指的是在一个分布式系统中：一致性（Consistency）：在分布式系统中的所有数据备份，在同一时刻是一致的。
Spring事务隔离级别以及事务传播机制
weixin_42573367的博客
06-21 333
事务 事务分为编程式事务TransactionTemplate.execute(TransactionCallback<T> action)和声明式事务(基于AspectJ的XML方式、基于AspectJ的注解方式)。 事务的四大特性（ACID） 原子性：操作要么全成功，要么全失败回滚。 一致性：一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。 隔离性：事务之间互不干扰 持久性：事务一旦提交，数据的改变是永久性的。
SpringBoot 注解事务声明式事务的方式
08-29
`@Transactional`还可以设置`isolation`属性来指定事务的隔离级别，例如： - `ISOLATION_DEFAULT`: 使用数据库默认的隔离级别。 - `ISOLATION_READ_UNCOMMITTED`: 最低的隔离级别，允许读取尚未提交的数据变更，...
springboot开启声明式事务的方法
08-30
SpringBoot开启声明式事务的方法 声明式事务是一种编程模型，它允许开发者在应用程序中声明事务边界，而不需要编写事务管理代码。SpringBoot框架提供了对声明式事务的支持，使得开发者可以更方便地使用事务管理。 ...
Spring Boot多数据源(支持Spring声明式事务切换和回滚).pdf
07-21
《Spring Boot多数据源(支持Spring声明式事务切换和回滚)》 Spring Boot多数据源技术是构建高效、灵活的多租户SaaS架构的关键。在本文中，我们将深入探讨如何实现动态数据源切换，支持Spring声明式事务管理，并讨论...
基于Springboot+ActiveMQ事务==本地事件表+activemq.zip
12-12
分布式事务通常面临的挑战是如何在多个操作之间保证ACID（原子性、一致性、隔离性、持久性）属性。在这个方案中，本地事件表是一种补偿事务策略，也称为Saga模式。当一个分布式事务由多个子事务组成时，每个子事务...
使用MyBatisPlus+Spring实现声明式事务
03-09
与编程式事务管理（在代码中显式地开始、提交和回滚事务）不同，声明式事务管理允许我们在配置文件或注解中定义事务边界，从而让Spring框架自动处理事务的生命周期。这种方式更加简洁且易于维护。 1. **集成...
Spring事务，隔离性，传播性记录分析
何xiao树
02-22 800
目的：当一个方法内，有操作多张关联表数据的操作时，为保证数据的一致性，需要对这个方法开启事务。 当方法内有异常时，则会进行回滚，数据返回到事务操作前；spring事务的数据回滚依赖于数据库对事务的支持 事务特性: A -原子性 ：事务内的数据修改操作要么都成功，要么都失败 C -一致性 ：事务内相关联数据的一致性 I - 隔离型 ：事务与事务之间的数据相互隔离互不影响 D -持久性 ： 事务正常结束对表数据的修改是持久的 事务间的数据隔离级别 :(级别由低->高) READ_UN.
带你读懂Spring 事务——事务的隔离级别（超详细，快藏）
爱做梦的锤子
06-02 4027
读懂Spring事务的第三篇，超详细的对事物的隔离级别进行了讲解，看完保证有收获，一篇更比6篇强
Spring之事务详解
热门推荐
上善若泪
02-25 1万+
1.Spring事物的定义： 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。 如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。 当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。 由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。 2. spring七个事务传播属性： PROP......
SpringBoot的事务与锁
piaopu0120的博客
04-28 2683
数据库里的事务保证的是要么全部完成要么全部不起作用。在开启事务的时候，会有不同的数据库锁保证并发性。但是并不能保证我们执行逻辑的正确性，见下面的例子。本质的原因是，我们使用Java的对象锁，可以保证临界区只有一个线程访问，但是这和SpringBoot里加。所以本质就是第一个操作没加锁，除非直接加表级锁，但是效率太低了。第二步update就是当前读了，走了主键索引，会触发行级锁。所以可以用Java的对象锁来解决这个问题，但是不是简单的加。可以看出，加锁的类型是X型的记录锁，对那一行加了锁。
spring-事务和锁顺序的问题
面朝大海，春暖花开
08-28 448
经常会在事务中方法中使用锁。
Spring Boot中的事务隔离级别
u013749113的博客
06-27 1555
事务隔离级别是Spring Boot中一个非常重要的概念，它可以帮助开发者控制数据库操作的并发性和一致性。Spring Boot支持4种事务隔离级别，包括READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ和SERIALIZABLE。开发者可以使用@Transactional注解来开启一个事务，并指定事务隔离级别。事务隔离级别的实现依赖于数据库的锁机制和隔离级别设置。使用事务隔离级别时，开发者需要根据实际情况选择合适的隔离级别，以达到最佳的数据库操作效果。
MySQL事务隔离级别和Spring事务关系介绍
蜗牛的专栏
01-15 1万+
事务隔离级别介绍 隔离级别 脏读 不可重复读 幻读 未提交读（Read uncommitted） 可能 可能 可能 已提交读（Read committed） 不可能 可能 可能 可重复读（Repeatable read） 不可能 不可能 可能 可
SpringBoot&MySq中设置默认事务隔离等级详解
白石的专栏
08-24 3367
SpringBoot&MySq中设置默认事务隔离等级详解
springboot声明式事务
07-29
Spring Boot提供了一种简单而强大的方式来处理事务，即声明式事务。声明式事务是通过使用Spring框架的@Transactional注解来实现的。 在Spring Boot中，可以将@Transactional注解添加到类或方法上，以指示该类或方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值