@Transactional注解属性（2）

最新推荐文章于 2025-07-13 00:37:54 发布
最新推荐文章于 2025-07-13 00:37:54 发布
阅读量311 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 事务 框架 Spring 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42867975/article/details/95937146
本文主要介绍了@Transactional注解的propagation属性，该属性指定事务传播行为。详细讲解了两种传播行为：REQUIRED默认在现有事务内运行，否则启动新事务；REQUIRES_NEW必须启动新事务，挂起现有事务。通过买书场景测试类分析了不同传播行为下事务的运行和回滚情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

@Transactional注解属性（2）

 文章目录

      4、propagation

propagation：指定事务传播行为，一个事务方法被另一个事务方法调用时，必须指定事务应该如何传播，例如：方法可能继承在现有事务中运行，也可能开启一个新事物。以下列举了两个事务的传播行为：

REQUIRED：默认值，如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行

测试类：

        场景：一个人（id为aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa）的钱包有100元，它想买两类书，第一类id为a2f39533-659f-42ca-af91-c688a83f6e49，数量为1本，单价为10元，该书库存为10本；第二类id为4c37672a-653c-4cc8-9ab5-ee0c614c7425，数量为10，单价为10元，该书库存为10本；

package com.jd.test;

import java.util.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.car.ICarService;
import com.jd.car.imp.CarService;

public class Test {
	
	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		ICarService carService = application.getBean(CarService.class);
		String userId = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
		Map<String,Integer> commodities = new HashMap<String,Integer>();
		commodities.put("a2f39533-659f-42ca-af91-c688a83f6e49",1);
		commodities.put("4c37672a-653c-4cc8-9ab5-ee0c614c7425",10);
		carService.batch(userId, commodities);
		application.close();
	}
}

CarService类

package com.jd.car.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jd.car.ICarService;
import com.jd.coupon.ICouponService;

@Service
public class CarService implements ICarService {

	@Autowired
	private ICouponService couponService;

	//购物车购买
	@Override
	@Transactional
	public boolean batch(String userId,Map<String,Integer> commodities) {
		Set<Entry<String, Integer>> set = commodities.entrySet();
		for (Entry<String, Integer> commodity : set) {
			String bookId = commodity.getKey();
			int count = commodity.getValue();
			System.out.println(bookId+","+count);
			couponService.insert(userId,bookId, count);
		}
		return true;
	}
}

CouponService类

package com.jd.coupon.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.jd.book.IBookDao;
import com.jd.coupon.ICouponDao;
import com.jd.coupon.ICouponService;
import com.jd.money.IMoneyDao;
import com.jd.vo.Coupon;

@Service
public class CouponService implements ICouponService {

	@Autowired
	private IBookDao bookDao;
	@Autowired
	private IMoneyDao moneyDao;
	@Autowired
	private ICouponDao couponDao;
	
	//立即购买
	@Override
	@Transactional/*(propagation=Propagation.REQUIRED)*/
	public boolean insert(String userId,String bookId, int count){
		
		if(bookDao.enough(bookId, count)) {//书籍足够
			//书籍表库存递减
			bookDao.update(bookId, count);
		}
		double price = bookDao.getPrice(bookId);
		double total = price*count;
		if(moneyDao.enough(userId, total)) {//余额足够
			//订单表添加数据
			Coupon coupon = new Coupon();
			coupon.setId(UUID.randomUUID().toString());
			coupon.setUserId(userId);
			coupon.setBookId(bookId);
			coupon.setTotal(total);
			couponDao.insert(coupon);
			//钱包表递减
			moneyDao.update(userId, total);
		}
		return true;
	}
}

分析：

       事务方法insert被另一个事务方法batch调用时，事务方法insert默认在batch方法的事务内运行，即insert方法和batch方法在同一个事务中（相当于修饰insert方法的@Transactional注解中添加了“propagation=Propagation.REQUIRED”属性），因此结算第二类书籍时钱包钱不够，insert方法抛出了异常以至于insert方法和batch方法所在的事务进行了回滚，最终导致第一类书籍的结算也时效，即书籍表、money表不会发生变化，且也不会生成订单，如下图所示：

book表数量依旧不变

money表账户余额依旧不变

coupon表不会生成订单

注意： 当删掉iCouponService类中insert方法的@Transactional/*(propagation=Propagation.REQUIRED)*/注解时，如下图所示：

package com.jd.coupon.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.jd.book.IBookDao;
import com.jd.coupon.ICouponDao;
import com.jd.coupon.ICouponService;
import com.jd.money.IMoneyDao;
import com.jd.vo.Coupon;

@Service
public class CouponService implements ICouponService {

	@Autowired
	private IBookDao bookDao;
	@Autowired
	private IMoneyDao moneyDao;
	@Autowired
	private ICouponDao couponDao;
	
	//立即购买
	@Override
	public boolean insert(String userId,String bookId, int count){
		
		if(bookDao.enough(bookId, count)) {//书籍足够
			//书籍表库存递减
			bookDao.update(bookId, count);
		}
		double price = bookDao.getPrice(bookId);
		double total = price*count;
		if(moneyDao.enough(userId, total)) {//余额足够
			//订单表添加数据
			Coupon coupon = new Coupon();
			coupon.setId(UUID.randomUUID().toString());
			coupon.setUserId(userId);
			coupon.setBookId(bookId);
			coupon.setTotal(total);
			couponDao.insert(coupon);
			//钱包表递减
			moneyDao.update(userId, total);
		}
		return true;
	}
}

此时如果购物车的batch方法处于事务中，虽然insert方法没有加事务注解，但在batch方法中被调用，因此和batch方法处于同一个事务中，也会事务回滚，但此时只有batch这一个事务，因此该现象不是事务的传播行为

REQUIRES_NEW：当前方法必须启动新事务，并在它自己的事务内运行，如果有事务在运行，则把当前事务挂起，直到新的事务提交或者回滚才恢复执行

测试类：

              场景：一个人（id为aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa）的钱包有100元，它想买两类书，第一类id为a2f39533-659f-42ca-af91-c688a83f6e49，数量为1本，单价为10元，该书库存为10本；第二类id为4c37672a-653c-4cc8-9ab5-ee0c614c7425，数量为10，单价为10元，该书库存为10本；

package com.jd.test;

import java.util.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.car.ICarService;
import com.jd.car.imp.CarService;

public class Test {
	
	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		ICarService carService = application.getBean(CarService.class);
		String userId = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
		Map<String,Integer> commodities = new HashMap<String,Integer>();
		commodities.put("a2f39533-659f-42ca-af91-c688a83f6e49",1);
		commodities.put("4c37672a-653c-4cc8-9ab5-ee0c614c7425",10);
		carService.batch(userId, commodities);
		application.close();
	}
}

CarService类

package com.jd.car.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jd.car.ICarService;
import com.jd.coupon.ICouponService;

@Service
public class CarService implements ICarService {

	@Autowired
	private ICouponService couponService;

	//购物车购买
	@Override
	@Transactional
	public boolean batch(String userId,Map<String,Integer> commodities) {
		Set<Entry<String, Integer>> set = commodities.entrySet();
		for (Entry<String, Integer> commodity : set) {
			String bookId = commodity.getKey();
			int count = commodity.getValue();
			System.out.println(bookId+","+count);
			couponService.insert(userId,bookId, count);
		}
		return true;
	}
}

CouponService类

package com.jd.coupon.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.jd.book.IBookDao;
import com.jd.coupon.ICouponDao;
import com.jd.coupon.ICouponService;
import com.jd.money.IMoneyDao;
import com.jd.vo.Coupon;

@Service
public class CouponService implements ICouponService {

	@Autowired
	private IBookDao bookDao;
	@Autowired
	private IMoneyDao moneyDao;
	@Autowired
	private ICouponDao couponDao;
	
	//立即购买
	@Override
	@Transactional(propagation=Propagation.REQUIRES_NEW)
	public boolean insert(String userId,String bookId, int count){
		
		if(bookDao.enough(bookId, count)) {//书籍足够
			//书籍表库存递减
			bookDao.update(bookId, count);
		}
		double price = bookDao.getPrice(bookId);
		double total = price*count;
		if(moneyDao.enough(userId, total)) {//余额足够
			//订单表添加数据
			Coupon coupon = new Coupon();
			coupon.setId(UUID.randomUUID().toString());
			coupon.setUserId(userId);
			coupon.setBookId(bookId);
			coupon.setTotal(total);
			couponDao.insert(coupon);
			//钱包表递减
			moneyDao.update(userId, total);
		}
		return true;
	}
}

分析：

              修饰insert方法的@Transactional注解中添加了“propagation=Propagation.REQUIRES_NEW”属性，则每次执行该方法时都会启动新事务，即有三个事务：第一类书籍购买为一个事务，第二类书籍购买为一个事务，batch为一个事务，所以结算第一类书籍时钱够库存也够则购买成功并提交当次事务，但结算第二类书籍时由于钱包钱不够导致支付失败，致使此次事务回滚，结果如下：

book表中，第一类书籍购买成功，数量由10变为零，第二类书籍数量依旧不变

money表中，买第一类书籍花掉100元，账户余额由100变为0

coupon表中生成订单

 

Java编程@Transactional注解的使用详解
wjianwei666的专栏
04-21 243
在实际开发中，我们可能会定义自己的异常类。这时候，如果自定义异常是 RuntimeException 的子类，那么@Transactional注解会默认回滚；如果是 Checked 异常，就需要像处理其他 Checked 异常一样，在注解中指定回滚该异常。需要注意的是，自定义异常的继承结构一定要正确，否则可能会导致回滚策略不符合预期。比如，如果你定义了一个自定义异常MyException，并且让它继承自 Exception（Checked 异常），那么在没有指定回滚该异常的情况下，事务不会回滚。
Spring @Transactional注解原理深度分析
ma451152002的专栏
06-17 124
Transactional注解是Spring事务管理的核心注解，定义在spring-tx@Inherited// 事务管理器限定符// 事务标签// 事务传播行为// 事务隔离级别// 事务超时时间// 只读事务标识// 回滚异常类型Class<?// 不回滚异常类型Class<?/*** 根据事务定义获取事务状态*//*** 提交事务*//*** 回滚事务*/@Component。
@Transactional 注解参数详解，以及注解的使用特性说明（典藏版）
热门推荐
Java Punk
11-25 1万+
通过本篇学习，你将加深对@Transactional 注解以及所有的属性的理解，还可以学习到@Transactional 注解常见的失效场景【文章最后】。
java 注解之@Transactional 注解
然而老干妈早就看穿了一切
06-09 2310
原文链接【程序员内点事】：https://juejin.im/post/5e72e97c6fb9a07cb346083f @Transactional 注解 它能保证方法内多个数据库操作要么同时成功、要么同时失败。 事务方面：主要分为2种 1.编程式事务 2.声明式事务 1.手动指定： try { //TODO something transactionManager.commit(status); } catch (Exception e) { tr...
@Transactional 详解
最新发布
mr_yuanshen的博客
07-13 640
事务传播机制就是: 多个事务⽅法存在调⽤关系时,事务是如何在这些⽅法间进⾏传播的.比如有两个⽅法A,B都被 @Transactional 修饰,A⽅法调⽤B⽅法A⽅法运⾏时,会开启⼀个事务.当A调⽤B时,B⽅法本⾝也有事务,此时B⽅法运⾏时,是加⼊A的事务,还是创建⼀个新的事务呢?这个就涉及到了事务的传播机制.⽐如公司流程管理执⾏任务之前,需要先写执⾏⽂档,任务执⾏结束,再写总结汇报此时A部⻔有⼀项⼯作,需要B部⻔的⽀援,此时B部⻔是直接使⽤A部⻔的⽂档,还是新建⼀个⽂档呢?
事务解答之@Transactional 注解的属性介绍
梦想不会灭
08-08 4305
@Transactional 是声明式事务管理 编程中使用的注解 1 .添加位置 1）接口实现类或接口实现方法上，而不是接口类中。 2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。 系统设计：最好将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：因为只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。如果想放在实现类上，
@Transactional 注解的属性
yiyaqin
12-08 917
属性 类型 描述 传播性 枚举型：Propagation 可选的传播性设置 隔离性 枚举型：Isolation 可选的隔离性级别（默认值：ISOLATION_DEFAULT） 只读性 布尔型 读写型事务 vs. 只读型事务 超时 int型（以秒为单位） 事务超时 回滚异常类（rollbackFor） 一组 Class
@Transactional详解
Champion-Dai
03-04 1万+
快速了解@Transactional
Spring @Transactional注解失效解决方案
08-25
如果是 checked 异常，可以在 @Transactional 注解上指定 rollbackFor 属性，例如 @Transactional(rollbackFor=Exception.class)。 3. 确认数据库引擎是否支持事务。如果是 MySQL，需要使用支持事务的引擎，例如 ...
test-transactional:关于spring中@Transactional注解传播属性原理的实验
04-27
关于spring中@Transactional注解传播属性原理的实验 具体方法： 主体形式：a方法调用b方法 a插入数据“one” b插入数据“two” a、b方法都可以有不同的传播级别或者不加事务注解（none）: required(rd), required_...
Spring 中的 @Transactional注解详解
weixin_42564451的博客
08-03 2309
@Transactional是Spring框架提供的一个注解，用于简化事务管理。它可以应用于类或方法上，以指定该类或方法的事务行为。
【Spring】@Transactional事务属性详解
hhb442的博客
12-13 936
注解开启事务，其中注解的各种属性详解。
Spring的@TranSactional注解属性说明
qq_41869296的博客
05-16 1284
今日工作内容：完成了仓库的入库事务的注解属性的说明：propagation:事务传播行为。isolation:事务隔离级别。readOnly：事务的读写性，boolean型。timeout：超时时间，int型，以秒为单位。rollbackFor：一组异常类，遇到时回滚。（rollbackFor={SQLException.class}）。rollbackForCalssName:一组异常类名，遇到...
@Transactional注解属性（3）
weixin_42867975的博客
07-15 338
@Transactional注解属性（3） 文章目录 1、问题 2、解决方案 1、问题 同一个应用程序中的多个事务或不同应用程序中的多个事务在同一个数据集上并发执行时, 可能会出现许多意外的问题，这些问题可分为如下三种类型： 脏读(Drity Read)：已知有两个事务A和B, A读取了已经被B更新但还没有被提交的数据，...
spring 的@Transactional注解 学习
weixin_42354735的博客
01-21 606
@Transactional注解的属性   属性 类型 描述 value String 可选的限定描述符，指定使用的事务管理器 propagation enum: Propagation 可选的事务传播行为设置 isolation enum: Isolation 可选的事务隔离级别设置 readOnly boolean ...
@Transactional属性详解
棉花糖的博客
05-14 3462
文章目录@Transactional属性详解使用说明注解失效问题@Transactional 应用在非 public 修饰的方法上@Transactional 注解属性 rollbackFor 设置错误同一个类中方法调用，导致@Transactional失效异常被你的 catch“吃了”导致@Transactional失效数据库引擎不支持事务开启多线程任务时，事务管理会受到影响 @Transactional属性详解 声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或
Spring `@Transactional` 属性深度解析：从理论到实践
xycxycooo的博客
09-29 2297
注解提供了多个属性，用于配置事务的行为，包括传播行为、隔离级别、超时时间、只读事务和回滚规则。通过合理配置这些属性，开发者可以在应用程序中实现灵活的事务管理。本文通过详细的代码示例和解释，展示了注解的各个属性的工作原理及其在实际项目中的应用。希望本文能够帮助程序员更好地理解和应用 Spring 事务管理，提升开发效率和代码质量。
【事务】@Transactional 注解参数详解
DreamSun的博客
05-30 6802
通过本篇学习，你将加深对 @Transactional 注解以及所有的属性的理解，还可以学习到 @Transactional 注解常见的失效场景。@Target({ElementType.TYPE, ElementType.METHOD})：设定注解使用范围是类和方法上；@Retention(RetentionPolicy.RUNTIME)：设定生命周期为全周期，支持使用反射机制的代码读取和使用；@Inherited：指明如果该注解修饰的父类被子类继承，那么子类也具备事务特性；
@Transactional注解
arkitocy的博客
12-22 275
@Transactional注解 一.事物传播行为介绍: @Transactional(propagation=Propagation.REQUIRED) ：如果有事务, 那么加入事务, 没有的话新建一个(默认情况下) 　　@Transactional(propagation=Propagation.NOT_SUPPORTED) ：容器不为这个方法开启事务 　　@Transactional(pro...
@transactional注解属性解析
05-12
@transactional 是 Spring 框架中用于管理事务的注解，它可以被应用到类或方法上。 在类级别上，@transactional 注解可以被用于指定所有方法都应该被包装在一个事务中，也可以用于继承性地声明该类中所有方法都应该被事务性地执行。 在方法级别上，@transactional 注解可以被用于指定该方法应该被包装在一个事务中。它可以接受一系列属性来定制事务的行为： - propagation 指定事务的传播行为，默认值为 REQUIRED。 - isolation 指定事务的隔离级别，默认值为 DEFAULT。 - timeout 指定事务的超时时间，默认值为 -1（即使用默认超时时间）。 - readOnly 指定事务是否为只读事务，默认值为 false。 - rollbackFor 指定需要回滚的异常类型，默认值为 {}。 - noRollbackFor 指定不需要回滚的异常类型，默认值为 {}。 例如，下面的代码展示了一个使用 @transactional 注解的示例： ``` @Service public class UserService { @Autowired private UserRepository userRepository; @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false) public void saveUser(User user) { userRepository.save(user); } } ``` 在这个示例中，saveUser() 方法会被包装在一个事务中，并且事务的传播行为为 REQUIRED，事务的隔离级别为 DEFAULT，事务是读写的，如果发生 RuntimeException 异常，事务会回滚。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值