关于spring事务的传播性这篇文章解析的非常清楚了,建议是先收藏再看!

逻辑极光
• 阅读 1672

spring事务的传播性

事务的传播性

研究的是多个事务存在时的处理策略
1)REQUIRED:如果存在一个事务,则支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。

2)SUPPORTS:如果存在一个事务,支持当前事务,如果当前没有事务,就以非事务方式执行。

3)MANDATORY:如果存在一个事务,支持当前事务,如果当前没有事务,就抛出异常。

4)REQUIRES_NEW:新建事务,如果当前存在事务,把当前事务挂起。

5)NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

6)NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。

7)NESTED:支持当前事务,新增Savepoint点,与当前事务同步提交或回滚。

个人整理了一些资料,有需要的朋友可以直接点击领取。

[Java基础知识大全](https://docs.qq.com/doc/DTW9N...
)

[22本Java架构师核心书籍](https://docs.qq.com/doc/DTW9N...
)

[从0到1Java学习路线和资料](https://docs.qq.com/doc/DTW9N...
)

[1000+道2021年最新面试题](https://docs.qq.com/doc/DTW9N...
)

测试前准备

准备好数据库表

数据库transaction_propagation
账号表account、书本表book、库存表book_stock

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for account
-- ----------------------------
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account`  (
  `user_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `balance` double(11, 2) UNSIGNED NULL DEFAULT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic STORAGE MEMORY;

-- ----------------------------
-- Records of account
-- ----------------------------
INSERT INTO `account` VALUES (1, 'Albert', 100.00);

-- ----------------------------
-- Table structure for book
-- ----------------------------
DROP TABLE IF EXISTS `book`;
CREATE TABLE `book`  (
  `book_id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `price` double(11, 2) UNSIGNED NULL DEFAULT NULL,
  PRIMARY KEY (`book_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1003 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of book
-- ----------------------------
INSERT INTO `book` VALUES (1001, '基础数据结构', 60.00);
INSERT INTO `book` VALUES (1002, '数据库设计', 50.00);

-- ----------------------------
-- Table structure for book_stock
-- ----------------------------
DROP TABLE IF EXISTS `book_stock`;
CREATE TABLE `book_stock`  (
  `book_id` int(11) NOT NULL AUTO_INCREMENT,
  `stock` int(11) UNSIGNED NULL DEFAULT NULL,
  PRIMARY KEY (`book_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1003 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of book_stock
-- ----------------------------
INSERT INTO `book_stock` VALUES (1001, 100);
INSERT INTO `book_stock` VALUES (1002, 100);

SET FOREIGN_KEY_CHECKS = 1;

初始化spring项目

导入一些基本依赖包:jdbc、mysql驱动包、测试模块;

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

数据库连接信息配置

#jdbc
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost/transaction_propagation?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

Service、Dao

这里只使用测试调用,省略controller以及entity等层构;

1、首先Dao类,编写一个购买的简单操作:查询单价、更新库存、更新账户余额;

@Repository
public class BookShopDao {

    @Autowired
    private JdbcTemplate jdbcTemplate = new JdbcTemplate();

    public double getPriceById(Integer bookId) {
        String sql = "SELECT price FROM BOOK WHERE book_id = ?";
        double price = jdbcTemplate.query(sql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement) throws SQLException {
                preparedStatement.setInt(1, bookId);
            }
        }, new ResultSetExtractor<Double>() {
            @Override
            public Double extractData(ResultSet resultSet) throws SQLException, DataAccessException {
                double p = 0.0;
                while (resultSet.next()) {
                    p = resultSet.getDouble("price");
                }
                return p;
            }
        });
        return price;
    }

    public void updateBookStock(Integer bookId, int num) {
        String sql = "UPDATE book_stock SET stock = stock - ? WHERE book_id = ?";
        jdbcTemplate.update(sql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement) throws SQLException {
                preparedStatement.setInt(1, num);
                preparedStatement.setInt(2, bookId);
            }
        });

    }

    public void updateBalance(Integer userId, double balance) {
        //修改金额
        String sql = "UPDATE account SET balance = balance - ? WHERE user_id = ?";
        jdbcTemplate.update(sql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement) throws SQLException {
                preparedStatement.setDouble(1, balance);
                preparedStatement.setInt(2, userId);
            }
        });
    }
}

2、研究事务传播学性其实就是研究两个以上的事务在嵌套时的应用方式,所以这里需要写两个Service进行嵌套调用;接口类此处省略
BookShopServiceImpl 中的purchase用@Transactional是指一个购买单进来必须保证(1、2、3)的原子性;

@Service
public class BookShopServiceImpl implements BookShopService {

    @Autowired
    private BookShopDao bookShopDao;

    @Transactional
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }
}

CashierServiceImpl 中buy方法中的@Transactional是指一个订单中出现多个购买单进来必须保证的原子性;
因为一个订单可能包含几种商品的购买。

@Service
public class CashierServiceImpl implements CashierService {

    @Autowired
    private BookShopService bookShopService;


    @Transactional
    @Override
    public void buy(List<Map<String,Object>> buys){
        for (Map map : buys){
            //购买
            bookShopService.purchase((Integer) map.get("userId"),(Integer)map.get("bookId"),(int)map.get("num"));
        }
    }
}

测试类

@SpringBootTest
public class TestBuy {

    @Autowired
    private CashierService cashierService;

    @Test
    void testBookShop(){
        List<Map<String,Object>> list = new ArrayList<>();
        Map<String,Object> map = new HashMap<>();
        map.put("userId",1);
        map.put("bookId",1001);
        map.put("num",1);
        list.add(map);
        map = new HashMap<>();
        map.put("userId",1);
        map.put("bookId",1002);
        map.put("num",1);
        list.add(map);
        try {
            cashierService.buy(list);
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("购买成功!");
    }
}

说明

以上是使用spring默认的事务传播:REQUIRED,purchase使用同一个事务提交。那就会出现这样的问题:账户上有100块钱,现在提交订单是买一本60块钱的《基础数据结构》以及一本50块钱的《数据库设计》;那么订单总金额是110元,显然账户上余额是不足够购买的,在第一次事务购买60块钱的《基础数据结构》是成功的,但再提交50块钱的《数据库设计》的时候就会抛出异常,那这时在CashierServiceImpl 的外层事务中就会异常并回滚。

使用其他传播性

REQUIRES_NEW

在purchase事务中声明(propagation = Propagation.REQUIRES_NEW);那么在每一次调用purchase时都会开启一个新的事务去提交;那么此时进行购买测试结果:第一本书就会购买成功,第二本书购买失败;因为异常回滚的是第二次调用的purchase事务。

 @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }

MANDATORY

会强制要求一个事务提交,否则抛出异常,测试结果与REQUIRED一样,回滚整个订单。

 @Transactional(propagation = Propagation.MANDATORY)
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }

如果外层没有事务就抛出异常
No existing transaction found for transaction marked with propagation ‘mandatory’

SUPPORTS

如果外层存在事务则以事务提交,测试结果与REQUIRED一样,回滚整个订单。

 @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }

如果外层不存在事务,则不以事务提交,将可以成功购买一本书;

NOT_SUPPORTED

以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。即外层是否有事务都不会影响结果:有一本书可购买成功。


    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }

NEVER

强制要求不能存在事务,否则抛出异常

@Transactional(propagation = Propagation.NEVER)
   @Override
   public void purchase(Integer userId,Integer bookId,int num){

       //1、获取要购买的图书价格
       double price = bookShopDao.getPriceById(bookId);
       //2、更新图书库存
       bookShopDao.updateBookStock(bookId,num);

       //3、更新用户余额
       bookShopDao.updateBalance(userId,price*num);
   }

存在事务则抛出异常:
Existing transaction found for transaction marked with propagation ‘never’

NESTED

支持当前事务,新增Savepoint点,与当前事务同步提交或回滚。 结果与REQUIRES一样,回滚整个订单。

    @Transactional(propagation = Propagation.NESTED)
    @Override
    public void purchase(Integer userId,Integer bookId,int num){

        //1、获取要购买的图书价格
        double price = bookShopDao.getPriceById(bookId);
        //2、更新图书库存
        bookShopDao.updateBookStock(bookId,num);

        //3、更新用户余额
        bookShopDao.updateBalance(userId,price*num);
    }
点赞
收藏
评论区
推荐文章
Easter79 Easter79
3年前
spring事务传播性(PROPAGATION)
spring事务传播性PROPAGATION\_REQUIRED简介加入当前已有事务;只有当前没有事务才启一个新的事务设计类ServiceA,方法methodA,事务级别定义为PROPAGATION_REQUIRED类ServiceB,方法method
Wesley13 Wesley13
3年前
MySQL数据库InnoDB存储引擎Log漫游(1)
作者:宋利兵来源:MySQL代码研究(mysqlcode)0、导读本文介绍了InnoDB引擎如何利用UndoLog和RedoLog来保证事务的原子性、持久性原理,以及InnoDB引擎实现UndoLog和RedoLog的基本思路。00–UndoLogUndoLog是为了实现事务的原子性,
Wesley13 Wesley13
3年前
mysql的innodb中事务日志ib_logfile
mysql的innodb中事务日志ib\_logfile事务日志或称redo日志,在mysql中默认以ib\_logfile0,ib\_logfile1名称存在,可以手工修改参数,调节开启几组日志来服务于当前mysql数据库,mysql采用顺序,循环写方式,每开启一个事务时,会把一些相关信息记录事务日志中(记录对数据文件数据修改的物理位置或
Wesley13 Wesley13
3年前
MySQL常见问题
事务四大特性原子性:不可分割的操作单元,事务中所有操作,要么全部成功;要么撤回到执行事务之前的状态一致性:如果在执行事务之前数据库是一致的,那么在执行事务之后数据库也还是一致的;隔离性:事务操作之间彼此独立和透明互不影响。事务独立运行。这通常使用锁来实现。一个事务处理后的结果,影响了其他事务,那么其他事务会撤回。
Easter79 Easter79
3年前
Spring事务用法示例与实现原理
       关于事务,简单来说,就是为了保证数据完整性而存在的一种工具,其主要有四大特性:原子性,一致性,隔离性和持久性。对于Spring事务,其最终还是在数据库层面实现的,而Spring只是以一种比较优雅的方式对其进行封装支持。本文首先会通过一个简单的示例来讲解Spring事务是如何使用的,然后会讲解Spring是如何解析xml中的标签,并对事务进行支持
Wesley13 Wesley13
3年前
Spring事务管理
Spring提供了一流的事务管理。在Spring中可以支持声明式事务和编程式事务。    本章主要目标如下:     1,Spring事务    2,事务属性    3,事务管理器    4,声明式事务      1.1Spring的事务     事务管理在应用程序中起着至关重要的作用:它是一系列任务
Wesley13 Wesley13
3年前
Mysql事务,并发问题,锁机制
1、什么是事务事务是一条或多条数据库操作语句的组合,具备ACID,4个特点。原子性:要不全部成功,要不全部撤销隔离性:事务之间相互独立,互不干扰一致性:数据库正确地改变状态后,数据库的一致性约束没有被破坏持久性:事务的提交结果,将持久保存在数据库中2、事务并发会产生什么问题1)第一类丢失更新:在没有事务隔离的情况下,两个事务都同时
Stella981 Stella981
3年前
Spring 事务配置的五种方式
前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。   总结如下: Spring事务类型详解:  PROPAGATION\_REQUIRED支持当前事务,如果当前没有事务,就新建一个事务。这
线上SQL超时场景分析-MySQL超时之间隙锁 | 京东物流技术团队
前言之前遇到过一个由MySQL间隙锁引发线上sql执行超时的场景,记录一下。背景说明分布式事务消息表:业务上使用消息表的方式,依赖本地事务,实现了一套分布式事务方案消息表名:mqmessages数据量:3000多万索引:createtime和statuss
Spring事务实现原理
1、引言spring的springtx模块提供了对事务管理支持,使用spring事务可以让我们从复杂的事务处理中得到解脱,无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。spring事务有编程式事务和声明式事务两种实现方式。编程式事务是通过编写代
京东云开发者 京东云开发者
8个月前
Spring事务实现原理
作者:京东零售范锡军1、引言spring的springtx模块提供了对事务管理支持,使用spring事务可以让我们从复杂的事务处理中得到解脱,无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。spring事务有编程式事务和声明式事务两种实现方式。编