spring事务 Propagation.REQUIRES_NEW、Propagation.NESTED、Propagation.REQUIRED使用时候发现的

最新推荐文章于 2024-05-03 23:59:42 发布
最新推荐文章于 2024-05-03 23:59:42 发布
阅读量3.5k 收藏 7
点赞数 5
分类专栏： spring 文章标签： spring 事务 Propagation.NESTED Propagation.REQUIRES Propagation.REQUIRED
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hepei120/article/details/78054291
版权

Spring事务的传播性与隔离级别
    Spring它对JDBC的隔离级别作出了补充和扩展，其提供了7种事务传播行为。
    1、PROPAGATION_REQUIRED：默认事务类型，如果没有，就新建一个事务；如果有，就加入当前事务。适合绝大多数情况。
    2、PROPAGATION_REQUIRES_NEW：如果没有，就新建一个事务；如果有，就将当前事务挂起。
    3、PROPAGATION_NESTED：如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。
    4、PROPAGATION_SUPPORTS：如果没有，就以非事务方式执行；如果有，就使用当前事务。
    5、PROPAGATION_NOT_SUPPORTED：如果没有，就以非事务方式执行；如果有，就将当前事务挂起。即无论如何不支持事务。
    6、PROPAGATION_NEVER：如果没有，就以非事务方式执行；如果有，就抛出异常。
    7、PROPAGATION_MANDATORY：如果没有，就抛出异常；如果有，就使用当前事务。
    第4、5、6、7种特性很好理解了，主要是前三种特性比较容易混淆或用错。

下面我用组合例子做个场景展示。

 

我的数据库有2个表

这个是账户余额表

 

这个是账户余额变更日志表

 

 

第一个例子 2个PROPAGATION_REQUIRED事务

 

 

@Transactional
	public String updateAccountTest(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			AccountMessage accountMessage = new AccountMessage();
			accountMessage.setMessage("修改用户" + accountTest.getName() + "金额" + accountTest.getMoney());
			accountMessageBusinessImpl.insertAccountMessageRequired(accountMessage);
			accountMessageBusinessImpl.updateAccountRequired(accountTest);
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		} catch (RuntimeException e) {
			throw e;
		}
		return strResult;

	}


@Transactional(propagation = Propagation.REQUIRED)
	public String updateAccountRequired(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			accountTestServiceImpl.updateObject("updateAccountTest", accountTest);
			int i = 1 / 0;// 将发生异常
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}

 

 

@Transactional(propagation=Propagation.REQUIRED)
	public String insertAccountMessageRequired(AccountMessage accountMessage) throws BusinessException {
		String strResult = "true";
		try {
			accountMessageServiceImpl.saveObject("insertAccountMessage", accountMessage);
		} catch (BusinessException e) {
			logger.error("类:AccountMessageServiceImpl;方法:insertAccountMessage;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;

	}

 

@Test
	public void test() {
		AccountTest accountTest = new AccountTest();
		accountTest.setAge(2);
		accountTest.setId(7);
		accountTest.setMoney(new BigDecimal(150));
		accountTest.setName("test");
		accountTestBusinessImpl.updateAccountTest(accountTest);
	}

 

我设置了一个runtimeException的异常抛出，事务的传播Propagation.REQUIRED,他的特点是如果有事务，就加入当前事务，可以看到这两个方法其实是在一个事务里。
执行updateAccountTest这个方法后，数据库的结果应该是

余额表未更新、账户余额变更日志表未插入

 


第2个例子 PROPAGATION_REQUIRED和PROPAGATION_REQUIRES_NEW组合

 

@Transactional  
	public String updateAccountTest(AccountTest accountTest) throws BusinessException {  
	    String strResult = "true";  
	    try {  
	        AccountMessage accountMessage = new AccountMessage();  
	        accountMessage.setMessage("修改用户" + accountTest.getName() + "金额" + accountTest.getMoney());  
	        accountMessageBusinessImpl.updateAccountRequiresNew(accountTest); //如果updateAccountRequiresNew这个方法在本类定义,this.updateAccountRequiresNew(accountTest)，结果又会是怎么样呢
	        accountMessageBusinessImpl.insertAccountMessageRequired(accountMessage);  
	    } catch (BusinessException e) {  
	        logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);  
	        strResult = "false";  
	        throw e;  
	    } catch (RuntimeException e) {  
	        throw e;  
	    }  
	    return strResult;  
	}

 

 

 

 

 

 

@Transactional(propagation=Propagation.REQUIRED)
	public String insertAccountMessageRequired(AccountMessage accountMessage) throws BusinessException {
		String strResult = "true";
		try {
			accountMessageServiceImpl.saveObject("insertAccountMessage", accountMessage);
			int i=1/0;
		} catch (BusinessException e) {
			logger.error("类:AccountMessageServiceImpl;方法:insertAccountMessage;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}
@Transactional(propagation=Propagation.REQUIRES_NEW)
	public String updateAccountRequiresNew(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			accountTestServiceImpl.updateObject("updateAccountTest", accountTest);
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}

 

 

 

@Test
	public void test() {
		AccountTest accountTest = new AccountTest();
		accountTest.setAge(2);
		accountTest.setId(7);
		accountTest.setMoney(new BigDecimal(150));
		accountTest.setName("test");
		accountTestBusinessImpl.updateAccountTest(accountTest);
	}

 

 

 

 

 

 

 

这个时候的结果是 余额表更新了

账户余额变更日志表没变


看方法的执行顺序,先执行了updateAccountRequiresNew ，再执行insertAccountMessageRequired，
异常是在insertAccountMessageRequired抛出的，因为updateAccountRequiresNew这个方法新建了一个事务,他的方法执行完就commit。insertAccountMessageRequired这个rollback了。

 


第3个例子 PROPAGATION_NESTED嵌套事务
他的特点是
                1.联合成功（PROPAGATION_REQUIRED的特性） 
2.隔离失败（PROPAGATION_REQUIRES_NEW的特性）。
在测试PROPAGATION_NESTED 之前时候我先用PROPAGATION_REQUIRED演示一下
 

 

@Transactional
	public String updateAccountTest(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			AccountMessage accountMessage = new AccountMessage();
			accountMessage.setMessage("修改用户" + accountTest.getName() + "金额" + accountTest.getMoney());
			try {
				accountMessageBusinessImpl.insertAccountMessageRequired(accountMessage);
			} catch (RuntimeException e) {
				accountMessageBusinessImpl.updateAccountRequired(accountTest);
				throw e; // 如果注释 Transaction rolled back because it has been marked as rollback-only。

			}
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		} catch (RuntimeException e) {
			throw e;
		}
		return strResult;
	}

	@Transactional(propagation=Propagation.REQUIRED)
	public String updateAccountRequired(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			accountTestServiceImpl.updateObject("updateAccountTest", accountTest);
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}
@Transactional(propagation=Propagation.REQUIRED)
	public String insertAccountMessageRequired(AccountMessage accountMessage) throws BusinessException {
		String strResult = "true";
		try {
			accountMessageServiceImpl.saveObject("insertAccountMessage", accountMessage);
			int i=1/0;
		} catch (BusinessException e) {
			logger.error("类:AccountMessageServiceImpl;方法:insertAccountMessage;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}

 

@Test
	public void test() {
		AccountTest accountTest = new AccountTest();
		accountTest.setAge(2);
		accountTest.setId(7);
		accountTest.setMoney(new BigDecimal(180));
		accountTest.setName("test");
		accountTestBusinessImpl.updateAccountTest(accountTest);
	}


为了区分这次将余额修改成180

 

结果和上次比并没有变化

余额表没有更新

日志表未添加记录

 

 

 

 

PROPAGATION_NESTED 开始一个 "嵌套的" 事务,  它是已经存在事务的一个真正的子事务. 潜套事务开始执行时,  它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交. 

现在可以测试错误隔离了

 

@Transactional
	public String updateAccountTest(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			AccountMessage accountMessage = new AccountMessage();
			accountMessage.setMessage("修改用户" + accountTest.getName() + "金额" + accountTest.getMoney());
			try{
				accountMessageBusinessImpl.insertAccountMessageNested(accountMessage);
			}catch(RuntimeException e){
				accountMessageBusinessImpl.updateAccountRequired(accountTest);
			}
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		} catch (RuntimeException e) {
			throw e;
		}
		return strResult;
	}

 

@Transactional(propagation=Propagation.NESTED)
	public String insertAccountMessageNested(AccountMessage accountMessage) throws RuntimeException {
		String strResult = "true";
		try {
			accountMessageServiceImpl.saveObject("insertAccountMessage", accountMessage);
			int i=1/0;
		} catch (BusinessException e) {
			logger.error("类:AccountMessageServiceImpl;方法:insertAccountMessage;错误信息:" + e);
			strResult = "false";
			throw e;
		}catch(RuntimeException e){
			throw e;
		}
		return strResult;
	}
@Transactional(propagation=Propagation.REQUIRED)
	public String updateAccountRequired(AccountTest accountTest) throws BusinessException {
		String strResult = "true";
		try {
			accountTestServiceImpl.updateObject("updateAccountTest", accountTest);
		} catch (BusinessException e) {
			logger.error("类:AccountTestServiceImpl;方法:updateAccountTest;错误信息:" + e);
			strResult = "false";
			throw e;
		}
		return strResult;
	}

 

	@Test
	public void test() {
		AccountTest accountTest = new AccountTest();
		accountTest.setAge(2);
		accountTest.setId(7);
		accountTest.setMoney(new BigDecimal(180));
		accountTest.setName("test");
		accountTestBusinessImpl.updateAccountTest(accountTest);
	}



结果是日志表未插入新纪录

 

余额表发生更新

 





由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于,PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit,这个规则同样适用于 roll back.

 

NESTED的具体用途如下：在此方法出现异常时,通过TRY CATCH 代码块包含住, 继续往下执行或者执行CATCH中的处理.此点REUQIRED做不到, REQUIRED_NEW能做到, 但它是单独的事务，不与父类一块提交的

hepei120
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈spring中isolation和propagation的用法
08-18
4. PROPAGATION_REQUIRES_NEW：表示当前方法必须在它自己的事务里运行。一个新的事务将被启动，而且如果有一个现有事务在运行的话，则将在这个方法运行期间被挂起。 5. PROPAGATION_NOT_SUPPORTED：表示当前方法不...
spring事务管理.rar
05-07
@Transactional(propagation = Propagation.REQUIRES_NEW) public void updateUser(Long id) { // 更新用户操作 User user = userRepository.findById(id).orElseThrow(); user.setName("New Name"); ...
PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED 区别
04-08 1955
PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit, 这个规则同样适用于 roll back ...
Spring的嵌套事务(Propagation.NESTED)到底是个啥
cainiao1412的博客
01-06 3821
SavePoint是数据库事务中的一个概念, 可以将整个事务切割为不同的小事务, 可以选择将状态回滚到某个小事务发生时的样子。Propagation.NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于rollback.嵌套事务开始执行时, 它将取得一个 savepoint, 如果这个嵌套事务失败, 我们将回滚到此 savepoint，嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.
Spring事务七大传播机制与五个隔离级别，嵌套事务
最新发布
qq_43842093的博客
05-03 973
如果当前方法正有一个事务在运行中，则该方法应该运行在一个嵌套事务中，被嵌套的事务可以独立于被封装的事务中进行提交或者回滚。如果封装事务存在，并且外层事务抛出异常回滚，那么内层事务必须回滚，反之，内层事务并不影响外层事务。当前方法必须在一个具有事务的上下文中运行，如有客户端有事务在进行，那么被调用端将在该事务中运行，否则的话重新开启一个事务。当前方法必须运行在它自己的事务中。一个新的事务将启动，而且如果有一个现有的事务在运行的话，则这个方法将在运行期被挂起，直到新的事务提交或者回滚才恢复执行。
Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED
热门推荐
默默不代表沉默
07-10 2万+
在平常的项目里面，最常看到的就是使用注解@Transactional 去操作事务。 如果稍微对spring事物有过了解的，会知道关于事物传播机制，存在6种， 也就是： 同样可以在注解@Transactional里面看到， 默认配置了的是Propagation.REQUIRED （文章的主角） 而在这里也是其实告诉咱们，就算使用注解也是可以指定不同的事物机制： 为什么该篇文章，6种，我只介绍一种呢？而且是介绍的是PROPAGATION_REQUIRED 呢？...
propagation定义了7个事物传播行为
qq_36074064的博客
08-28 1018
REQUIRED：如果存在一个事物，则支持当前事物。如果没有事物则开启一个新的事物。 SUPPORTS：如果存在一个事物，支持当前事物。如果没有事物，则非事物的执行。但是对于事物同步的事务管理SUPPORTS与不使用事物有少许不同。 REQUIRES_NEW：总是开启一个新的事物。如果一个事物已经存在，则将这个存在的事物挂起。 NOT_SUPPORTED：总是非事物的执行，并挂起任何存在的事
Spring 事务传播机制源码浅析——PROPAGATION_REQUIRES_NEW
龚小帅的博客
08-24 2507
两个方法都使用 PROPAGATION_REQUIRES_NEW 传播机制进行演示，并分析源码：示例如下： 还是要进入 TransactionInterceptor 类，这各类是入口，这里截取出核心源码如下：进入 createTransactionIfNecessary() 方法，可以分成六个核心步骤，源码如下：源码如下：可以发现第一步骤有两行非常重要的代码，第一行代码主要是从 ThreadLocal 类型的变量中去获取值，源码如下：第一次也就是现在过来的 add() 方法，现在从这个 ThreadLoc
Springboot中事务 @Transactional 默认方式 Propagation.REQUIRED
6个日的博客
03-23 1705
在平常的项目里面，最常看到的就是使用注解 @去操作事务。事务传播机制，存在7种，也就是：同样可以在注解@Transactional里面看到， 默认配置了的是 Propagation.REQUIRED （文章的主角）
spring-nested-aop.zip_aop_spring aop
09-23
@Transactional(propagation = Propagation.REQUIRED_NEW) public void createUser(User user) { // 业务逻辑... userRepository.save(user); updateUserProfile(user); } @Transactional(propagation = ...
深入理解Spring事务的传播行为
08-26
Spring事务的传播行为是Spring框架在事务管理中的一项重要特性，它定义了在不同事务上下文中如何执行方法的规则。这些行为由`TransactionDefinition`接口中的7种常量表示，它们分别为： 1. `PROPAGATION_REQUIRED`:...
Spring Nested事务简单案例
11-22
这里是Spring的一个Nested事务的代码及数据库文件,因为NESTED资源很少,这里作出了一个通俗易懂的 让需要者下载。
Spring事务简介.docx
06-19
- **PROPAGATION_REQUIRES_NEW**：总是开始一个新的事务，即使在已有事务中，当前事务会被挂起，结束后恢复原事务。 - **PROPAGATION_SUPPORTS**：如果已有事务，就加入该事务，否则以非事务方式运行。 - **...
Spring 事务传播机制源码浅析——PROPAGATION_PROPAGATION_NESTED 事务嵌套
龚小帅的博客
08-24 904
举个例子：下面有三条执行语句，先后对 age 字段做了相应的修改，但是有时候我希望保留第一次的修改值，第二、三次修改给我回滚，这个时候就需要使用到保存点 savepoint 了。创建 savepoint 保存点，用来标志回滚到什么位置，回滚操作，只需要 rollback b，这样就只保留了第一次修改，其他两次修改都不会成功，这就是 savepoint 的作用进入源码如下：获取到 Connection 连接对象，调用 JDBC API 创建保存点。
事物传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题
fenjindecainiao1的博客
10-24 5783
@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED, rollbackFor = {Throwable.class}, readOnly = false) 传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题 因为： 由...
事务的传播行为
qq_36722039的博客
07-18 295
举例： 用户想要买两本书，但是账户的钱只够支付一本书，这时需要先支付一本。 如果事默认的事务传播行为（REQUIRED），则两本书都不能购买成功，这是需要将事务的传播行为设置为REQUIRES_NEW 重点事这两种传播行为： REQUIRED 传播行为： 默认的事务传播行为，当前方法内的所有方法都在一个事务中，要么都成功，要么都不成功。 @Transactional(propaga...
Spring事务传播问题 — PROPAGATION_REQUIRES_NEW
BraveHeart
06-11 1717
原文：https://blog.csdn.net/wangjunjun2008/article/details/53669951 一、描述 Spring遇到嵌套事务时，当被嵌套的事务被定义为“PROPAGATION_REQUIRES_NEW”时， 内层Service的方法被调用时，外层方法的事务被挂起； 内层事务相对于外层事务是完全独立的，有独立的隔离性等等。 二、实验 但实验时却遇到一个奇怪的问...
23.下面有关Spring的事务传播特性，说法错误的是（） ☆ 【单选】 A. PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行 B. PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常 C. PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起 D. PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行，如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作
05-05
B. PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常 是错误的说法。PROPAGATION_REQUIRED表示支持当前事务，如果当前没有事务，就新建一个事务。如果被调用方存在事务，则加入该事务中，否则新建一个事务。如果该事务被外层事务包裹，则被外层事务控制提交或回滚。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值