Spring事物的传播特性详解
一、事务的传播性
研究的是多个事务存在时的处理策略
1）REQUIRED：如果存在一个事务，则支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
2）SUPPORTS：如果存在一个事务，支持当前事务，如果当前没有事务，就以非事务方式执行。
3）MANDATORY：如果存在一个事务，支持当前事务，如果当前没有事务，就抛出异常。
4）REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
5）NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
6）NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
7）NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚。
二、测试前准备
2.1、准备好数据库表
数据库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;
2.2、初始化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>
2.3、数据库连接信息配置
#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
2.4、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"));
}
}
}
2.5、测试类
@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("购买成功！");
}
}
2.6、说明
以上是使用spring默认的事务传播：REQUIRED，purchase使用同一个事务提交。那就会出现这样的问题：账户上有100块钱，现在提交订单是买一本60块钱的《基础数据结构》以及一本50块钱的《数据库设计》；那么订单总金额是110元，显然账户上余额是不足够购买的，在第一次事务购买60块钱的《基础数据结构》是成功的，但再提交50块钱的《数据库设计》的时候就会抛出异常，那这时在CashierServiceImpl 的外层事务中就会异常并回滚。
三、使用其他传播性
3.1、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);
}
3.2、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'**
3.3、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);
}
如果外层不存在事务，则不以事务提交，将可以成功购买一本书；
3.4、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);
}
3.5、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'
3.6、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);
}
到此这篇关于Spring事物的传播性详解的文章就介绍到这了,更多相关Spring事物的传播性内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
深入理解Spring事务的传播行为
前言 本文主要介绍下Spring事务中的传播行为.事务传播行为是Spring框架独有的事务增强特性,他不属于的事务实际提供方数据库行为.这是Spring为我们提供的强大的工具箱,使用事务传播行可以为我们的开发工作提供许多便利. 下面话不多说了,来一起看看详细的介绍吧 事务传播行为介绍 Spring中的7个事务传播行为: |事务行为|说明 | |:--|:--| |PROPAGATION_REQUIRED | 支持当前事务,假设当前没有事务.就新建一个事务 | | PROPAGATION_SUPP
-
Spring中事务传播行为的介绍
传播行为定义关于客户端和被调用方法的事务边界.Spring定义了7种截然不同的传播行为. 1,PROPAGATION_MANDATORY,表示该方法必须运行在一个事务中.如果当前没有事务正在发生,则抛出异常. 2,PROPAGATION_NESTED,表示如果当前有一个事务正在运行当中,则该方法应该运行在一个嵌套事务中.被嵌套的事务可以独立于封装事务进行提交或回滚.如果封装事务不存在,则行为就像PROPAGATION_REQUIRED一样. 3,PROPAGATION_NEVER,表示当前方法不
-
Spring事务传播行为问题解决
这篇文章主要介绍了Spring事务传播行为问题解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.简介 Spring事务配置及相关说明详见:https://www.jb51.net/article/177710.htm.这里说明spring事务的几点注意: 1.默认只会检查回滚RuntimeException的异常. 2.@Transactional注解只能作用于public的方法上,默认传播行为 Propagation.REQUIRED
-
Spring 事务隔离与事务传播的详解与对比
Spring 事务隔离与事务传播的详解与对比 Spring是SSH中的管理员,负责管理其它框架,协调各个部分的工作.今天一起学习一下Spring的事务管理.Spring的事务管理分为声明式跟编程式.声明式就是在Spring的配置文件中进行相关配置:编程式就是用注解的方式写到代码里. Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource.TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分. DataSource. Tr
-
Spring事务传播属性和隔离级别详细介绍
1 事务的传播属性(Propagation) 1) REQUIRED ,这个是默认的属性 Support a current transaction, create a new one if none exists. 如果存在一个事务,则支持当前事务.如果没有事务则开启一个新的事务. 被设置成这个级别时,会为每一个被调用的方法创建一个逻辑事务域.如果前面的方法已经创建了事务,那么后面的方法支持当前的事务,如果当前没有事务会重新建立事务. 2) MANDATORY Support a curren
-
深入理解Spring的事务传播行为
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为.事务传播行为是Spring框架独有的事务增强特性,他不属于的事务实际提供方数据库行为.这是Spring为我们提供的强大的工具箱,使用事务传播行可以为我们的开发工作提供许多便利.但是人们对他的误解也颇多,你一定也听过"service方法事务最好不要嵌套"的传言.要想正确的使用工具首先需要了解工具.本文对七种事务传播行为做详细介绍,内容主要代码示例的方式呈现. 基础概念 1. 什么是事务传播行
-
spring事务隔离级别、传播机制以及简单配置方式
一.spring支持的事务声明方式 1. 编程式事务 当系统需要明确的,细粒度的控制各个事务的边界,应选择编程式事务. 2. 声明式事务 当系统对于事务的控制粒度较粗时,应该选择申明式事务,通过<tx>标签和<aop>切面形式在xml中进行配置. 3. 无论你选择上述何种事务方式去实现事务控制,spring都提供基于门面设计模式的事务管理器供选择,如下是spring事务中支持的事务管理器 事务管理器实现(org.springframework.*) 使用时机 jdbc.dataso
-
这一次搞懂Spring事务是如何传播的
前言 上一篇分析了事务注解的解析过程,本质上是将事务封装为切面加入到AOP的执行链中,因此会调用到MethodInceptor的实现类的invoke方法,而事务切面的Interceptor就是TransactionInterceptor,所以本篇直接从该类开始. 正文 事务切面的调用过程 public Object invoke(MethodInvocation invocation) throws Throwable { // Work out the target class: may be
-
spring事物传播propagation类别含义详解
这篇文章主要介绍了spring事物传播propagation类别含义详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在spring事务中针对注解transaction,我们在定义的时候会注明事物的传播类别,默认的是required. required:使用当前的事务,如果当前没有事务,则自己新建一个事务,子方法必须运行在一个事务,如果当前存在事务,则加入这个事务,成为一个整体. ex:领导没饭吃,我有钱,我自己买了自己吃:领导有饭吃,会分给
-
Spring中的事务传播行为示例详解
一.背景介绍 Spring 框架应该是每一个人 javaer 都必须接触和学习的技术,Spring 公司所提供的各种框架是 Java 开发行业可参考的重要标准之一. Spring 中有 7 种类型的事务传播行为.事务传播行为是 Spring 框架提供的一种事务管理方式,它是 Spring 框架之中非常重要的一个技术点,毕竟事务关系到应用程序和数据库的交互,而数据更是互联网行业最为重要的资源. 平时开发过程中事务都会有使用,但是没有真正地总结过,尤其是事务中嵌套事务的场景,此篇基础知识文在此做一个
-
浅谈Spring事务传播行为实战
Spring框架提供了事务管理的标准实现,且可以通过注解或者XML文件的方式声明和配置事务. 通过异步事件的方式解耦服务调用,可以提高程序的响应速度,并且避免因为事务传播行为而导致的事务问题. 本文以一个电商平台包裹出库的业务为实际背景,通过异步事件与线程池的方式解耦嵌套事务,提高程序并发性能:为了便于问题的分析和方案的理解,同时还讲解了Spring的事务管理,并着重介绍了几种不同的事务传播行为. 事务小贴士 什么是事务呢?简单来讲事务就是逻辑上的一组操作,这些操作要么都执行,要么都不执行. 什