Spring 实现事务管理

最新推荐文章于 2024-07-17 18:39:15 发布
最新推荐文章于 2024-07-17 18:39:15 发布
阅读量543 收藏 1
点赞数 1
分类专栏： 事务 文章标签： spring 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zzze0101/article/details/95907546
版权

编程式事务管理：

将事务管理代码嵌入到业务方法中来控制事务的提交和回滚，在编程式管理事务中，必须在每个事务操作中包含额外的事务管理代码。https://blog.csdn.net/Zzze0101/article/details/90176413

声明式事务管理：

大多情况下比编程式事务管理更加好用，此方式将事务管理代码从业务代码中分离出来，以声明的方式实现事务管理，Spring声明式事务管理建立在AOP基础之上，是一个典型的横切关注点，通过环绕增强来实现，其原理是对方法前后进行拦截，然后在目标方法开始之前创建或加入一个事务，在执行完毕之后根据执行情况提交或回滚事务。
通过一个订单管理模块来说明Spring实现事务管理：

  1. 除Spring所需jar包之外还需要spring-aspects-4.2.5.RELEASE.jar
  2. 在Spring配置文件中添加如下配置：
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
  1. 在Service层public方法上添加事务注解——@Transactional
    （1）、一个类含有@Transactional注解修饰的方法，则Spring框架自动为该类创建代理对象，默认使用JDK创建代理对象。
    （2）、不能在protected、默认或者private的方法上使用@Transactional注解，否则无效。

@Transactional注解属性：

此文章只介绍@Transactional注解，不介绍代码内部方法如何实现

  1. rollbackFor和rollbackForClassName：指定对哪些异常回滚事务。
    默认情况下，如果在事务中抛出了运行时异常（继承自RuntimeException异常类），则回滚事务；如果没有抛出任何异常，或者抛出了检查时异常，则依然提交事务。这种处理方式是大多数开发者希望的处理方式，也是 EJB 中的默认处理方式；但可以根据需要人为控制事务在抛出某些运行时异常时仍然提交事务，或者在抛出某些检查时异常时回滚事务。
@Transactional(rollbackFor = MoneyException.class)//MoneyException为自定义运行时异常
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

执行结果：
若书籍库存不足则抛出异常，此时并没有进行DML语言，数据不变
若余额不足则抛出异常MoneyException，此时发生事务回滚，数据库中数据不会改变，
  1. noRollbackFor和noRollbackForClassName：指定对哪些异常不回滚事务。
    此属性在实际中一般不用，在此不在叙述。
  2. readOnly：事务只读，指对事务性资源进行只读操作。
    所谓事务性资源就是指那些被事务管理的资源，比如数据源、 JMS 资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么可以将事务标志为只读的，以提高事务处理的性能。
@Transactional(readOnly=true)//readOnly默认是false
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

执行结果：出现异常
SQL [update book set quantity = ? where id=?]; Connection is read-only. 
Queries leading to data modification are not allowed; nested exception is java.sql.
SQLException: Connection is read-only. 
Queries leading to data modification are not allowed
  1. timeout：设置一个事务所允许执行的最长时长（单位：秒）。
    如果超过该时长且事务还没有完成，则自动回滚事务且出现org.springframework.transaction.TransactionTimedOutException异常。
@Transactional(timeout=3)//readOnly默认是false
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	try {
		Thread.sleep(4000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

执行结果：抛出异常
org.springframework.transaction.TransactionTimedOutException:
Transaction timed out: deadline was Sun Jul 14 19:41:14 CST 2019
事务回滚，数据未改变

注意：

  • 事务的开始往往会发生数据库的表锁或者被数据库优化为行锁，如果允许时间过长，那么这些数据会一直被锁定，最终影响系统的并发性，因此可以给这些事务设置超时时间以规避该问题。
  • 由于超时是在一个事务启动的时候开始的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、ROPAGATION_NESTED）的方法来说，声明事务超时才有意义。
  1. propagation：指定事务传播行为.
    一个事务方法被另一个事务方法调用时，必须指定事务应该如何传播，例如：方法可能继承在现有事务中运行，也可能开启一个新事物，并在自己的事务中运行。
    Spring定义了如下7种事务传播行为：
  • REQUIRED：默认值，如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行；

场景：购物车模块，用户选择了“活着”，“朝花夕拾”两本书，两本书的价钱都为10元，但是用户余额只有10元，接着选择购买：

//注意下面两个方法在不同Service中，在之后会讲述区别
@Transactional
public boolean batch(String userId, Map<String, Integer> bookMap) {//实现购物车批量购买
	Set<Entry<String,Integer>> set = bookMap.entrySet();
	for (Entry<String, Integer> entry : set) {
		String bookName = entry.getKey();
		int bookNumber = entry.getValue();
		CouponService.insert(userId, bookName, bookNumber);//调用另一个Service中的insert方法
	}
return false;
}
@Transactional(propagation=Propagation.REQUIRED)//
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	try {
		Thread.sleep(4000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

执行结果：
余额不足！且数据库中书籍表，订单表，用户余额表均没有发生改变。虽然用户余额足够买一本书，但是，
对于两本书的购买处于同一个事务中，所以同时成功，同时失败。
  • REQUIRES_NEW：当前方法必须启动新事务，并在它自己的事务内运行，如果有事务在运行，则把当前事务挂起，直到新的事务提交或者回滚才恢复执行；
//注意下面两个方法在不同Service中，在之后会讲述区别
@Transactional
public boolean batch(String userId, Map<String, Integer> bookMap) {//实现购物车批量购买
	Set<Entry<String,Integer>> set = bookMap.entrySet();
	for (Entry<String, Integer> entry : set) {
		String bookName = entry.getKey();
		int bookNumber = entry.getValue();
		CouponService.insert(userId, bookName, bookNumber);//调用另一个Service中的insert方法
	}
return false;
}
@Transactional(propagation=Propagation.REQUIRES_NEW)//
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	try {
		Thread.sleep(4000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

还原场景之后再次执行（因为数据没有变化，所以不用还原）：

执行结果：
数据库中有一本书的数据发生变化，并且订单表有了一条新数据，说明购物车中一本书购买成功，
一本书购买失败，存在两个事务。

注意下面两个方法在同一个Service中

@Transactional
public boolean batch(String userId, Map<String, Integer> bookMap) {//实现购物车批量购买
	Set<Entry<String,Integer>> set = bookMap.entrySet();
	for (Entry<String, Integer> entry : set) {
		String bookName = entry.getKey();
		int bookNumber = entry.getValue();
		insert(userId, bookName, bookNumber);//调用另一个Service中的insert方法
	}
return false;
}
@Transactional(propagation=Propagation.REQUIRES_NEW)//
public boolean insert(String userId, String bookId, int count){//添加订单
	int i = bookDao.enough(bookId, count);//判断书籍库存
	if(i>=0) {
		bookDao.update(bookId, i);
	}else {
		throw new BookException("书籍库存不足！");//库存不足抛出自定义书籍异常
	}
	try {
		Thread.sleep(4000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	double price = bookDao.select(bookId).getPrice();//获取价格
	double total = price*count;//计算总价格
	if(moneyDao.enough(userId, total)) {//判断钱包余额是否足够
		Coupon coupon = new Coupon(userId, bookId, total);//新建订单
		couponDao.insert(coupon);//添加订单
		moneyDao.update(userId, total);//更新数据
	}else {
		throw new MoneyException("余额不足！");//余额不足抛出自定义余额异常
	}
return true;
}

还原场景之后再次执行：

执行结果：
余额不足！且数据库中书籍表，订单表，用户余额表均没有发生改变。虽然用户余额足够买一本书，并且
propagation=Propagation.REQUIRES_NEW，但是在同一个Service中这两个方法实践上还是在同一个事务中，
所以对于两本书的购买同时成功，同时失败。
  • SUPPORTS：如果有事务在运行，当前的方法就在这个事务内运行，否则以非事务的方式运行；
  • NOT_SUPPORTED：当前的方法不应该运行在事务中，如果有运行的事务，则将它挂起；
  • NEVER：当前方法不应该运行在事务中，否则将抛出异常；
  • MANDATORY：当前方法必须运行在事务内部，否则将抛出异常；
  • NESTED：如果有事务在运行，当前的方法在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行，此时等价于REQUIRED。

注意：对于NESTED内层事务而言，内层事务独立于外层事务，可以独立递交或者回滚,如果内层事务抛出的是运行异常，外层事务进行回滚，内层事务也会进行回滚。

  1. isolation：指定事务隔离级别，Spring定义了5种事务隔离级别。
Zzze0101
关注
专栏目录
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。 首先，让我们了解事务管理的基本概念。事务是一组数据库操作，这些操作要么全部执行，要么全部回滚，...
Spring事务管理Demo
05-01
本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 1. **编程式事务管理**：通过使用`PlatformTransactionManager`接口及其实现类（如`...
Spring如何基于aop实现事务控制
08-24
主要介绍了Spring如何基于aop实现事务控制,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring 事务管理
zhanshenlvbu321的博客
09-09 358
Spring+Hibernate的实质： 就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。 那么再没整合之前Hibernate是如何实现事务管理的呢？ 通过ServletFilter实现数据库事务的管理，这样就避免了在数据库操作中每...
Spring中事务是如何实现的？
最新发布
weixin_60246228的博客
07-17 301
11.Spring事务的传播机制是基于数据库连接来做的，一个数据库连接一个事务，如果传播机制配置为需要新开一个事务，那么实际上就是先建立一个数据库连接，在此新数据库连接上执行sql。5.并且修改数据库连接的autocommit属性为false，禁止此连接的自动提交，这是实现Spring事务非常重要的一步。10.Spring事务的传播机制是Spring事务自己实现的，也是Spring事务中最复杂的。8.如果出现了异常，并且这个异常是需要回滚的就会回滚事务，否则仍然提交事务。
Spring05——Spring 如何实现事务管理
Monster_WangXiaotu的博客
10-09 286
https://www.cnblogs.com/weechang/p/12608964.html
Spring事务是怎么实现的？
dayuiicghaid的博客
06-13 5681
1.Spring事务底层是基于数据库事务和AOP机制的 2.首先对于使用了@Transactional注解的Bean，Spring会创建一个代理对象作为Bean 3.当调用代理对象的方法时，会先判断该方法上是否加了@Transactional注解 4.如果加了，那么则利用事务管理器创建一个数据库连接 5.并且修改数据库连接的autocommit属性为false，禁止此连接的自动提交，这是实现Spring事务非常重要的一步 6.然后执行当前方法，方法中会执行sql 7.执行完当前方法后，如果没有出现异常就直接
Spring实现事务管理
童一的博客
02-27 211
学习目标： Spring事务管理的实现 学习内容： Spring的事务管理方法 学习时间： 学习产出： 事务 事务：在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。 事务ACID原则： 原子性（Atomicity）：是指一个事务要么全部执行，要么不执行，也就是说一个事务不可能只执行了一半就停止了 一致性（Consistency）：是指事务的运行并不改变数据库中数据的一致性。例如，完整性约束了a+b=10，一个事务改变了a，那么b也应该随之改变。 隔离性（Is
Spring3.0配置多个事务管理器的方法
01-20
在Spring框架中，事务管理是实现业务逻辑的重要组成部分，它确保了数据操作的一致性和完整性。Spring 3.0及更高版本提供了灵活的事务管理机制，允许开发者在同一个应用中配置并使用多个事务管理器，这尤其适用于处理...
Spring中的事务管理如何配置
08-25
在Spring框架中，事务管理可以通过配置和注解来实现。下面是一个基本的示例配置： 首先，需要创建一个配置类，用于配置事务管理： ```java @Configuration @EnableTransactionManagement @ComponentScan(...
spring cloud事务管理
06-20
尽管它主要关注数据处理，但也可以结合其他Spring Cloud组件实现事务管理。 2. **Spring Cloud Config**: 配置服务器可以用于配置事务管理器，特别是在分布式环境中，保持事务管理策略的一致性。 3. **Spring Cloud ...
spring事务管理是如何实现的？
weixin_42544499的博客
04-20 3250
spring的事务是由aop实现的，首先要生成具体的代理对象，然后按照aop的整套流程来执行具体的操作逻辑，正常情况下要通过通知来完成核心功能，但是事务不是通过通知来完成的，而是通过一个TransactionIntercaptor来实现的，然后调用invoke来实现具体的逻辑。 分： 1、先做准备工作，解析各个方法上事务相关的属性，根据具体的属性来判断是否开始新事务 2、当需要开启的时候，获取数据库连接，关闭自动提交功能，开启事务。 3、 执行具体的sql逻辑操作 4、在操作过程中，如果执行失败了，那么会通
你知道Spring使如何实现事务管理的?
weixin_45701550的博客
05-23 880
本文介绍了 Spring 如何实现事务管理。通过编程式事务管理和声明式事务管理，开发人员可以轻松地管理和控制事务的行为。编程式事务管理通过编写代码来管理事务的开始、提交和回滚等操作，而声明式事务管理通过配置来管理事务的行为，将事务管理与业务逻辑代码分离。在编程式事务管理中，我们配置了事务管理器，并使用 TransactionTemplate类来执行需要进行事务管理的代码块。通过 TransactionCallback回调接口，我们可以在事务内执行数据库操作，并在出现异常时手动设置事务回滚。
spring 事务管理实现方式
ChinFeng的专栏
05-20 992
注意：这里只是分析spring事务的实现方式。也就是spring的事务管理是怎么发生作用的，而不分析具体的实现细节 Spring是通过NameSpaceHandler来解析配置文件中的标签的。下面就已事务的配置为例，讲述一下 事务配置的标签的解析过程，从来理解事物是如何通过aop产生作用的。    以上的配置相信很多人已经很熟悉了，在此不赘述。而是具体分析一下原理。
Spring的事务管理实现原理初探
Rocky的博客
01-19 8358
这里主要是通过分析部分源码进行剖析Spring事务管理的实现原理。 再分析源码前，现从理论上大概分析哈： 纯JDBC操作数据库的基本步骤： 1. 获取连接 Connection conn = DriverManager.getConnection() 2. 开启事务conn.setAutoCommit(true/false); 3. 执行CRUD 4. 提交事务/回滚事务 conn.c
Spring 事务管理的实现分析
一阴一阳之谓道
03-05 1664
1、Spring 事务管理实现的基本模型在同一个 connection 里，【开启事务】-&gt;【执行method】-&gt;【回滚 OR 提交】2、注意点线程安全，每个线程同一个数据源只有一个connection 。当线程在执行一个有事务的方法时，通过数据源去获取connection。仅支持单个数据源的事务控制spring 抽象层 AbsPlatformTransactionManager，通...
事务以及在Spring中实现事务管理
HHHheziyan的博客
07-12 236
什么是事务 事务：逻辑上的一组操作，组成这组操作的单元，要么全部成功，要么全部失败。 事务的特性 原子性：事务不可分割 一致性：事务执行前后数据完整性保持一致 隔离性：一个事务的执行不应该受到其他事务的干扰 持久性：一旦事务结束，数据就持久化到数据库 不考虑隔离性引发的安全性问题 读问题 脏读： 一个事务读到另一个事务未提交的数据 不可重...
Spring管理事务
taxusw的博客
09-07 761
添加到类上面代表对该类的所有方法开启事务，添加到方法上面表示只针对该方法开启事务。（3）repeatable read（mysql默认）：解决了脏读，不可重复读，幻读仍然有可能出现。（2）read comitted：解决了脏读，不可重复读，幻读都有可能出现。（1）read uncomitted：脏读，不可重复读，幻读都有可能出现。指的是一个事务去调用另一个事务中的方法，主要有以下传播机制。默认值是-1，表示不提交，设置的值都是以秒为单位。（1）创建事务管理器，并注入数据源。解决措施（设置事务隔离级别）
spring（四）：事务管理的代码实现
谢康立的博客
08-23 450
spring（四）：事务管理的代码实现 一、JdbcTemplate JDBCTemplate是Spring框架对JDBC的简单封装 这个在我的《MySQL进阶（二）：连接池和JDBCTemplate》中有提及 个人博客传送门：http://1jumao.cn/index.php/archives/838/ CSDN博客传送门：https://blog.csdn.net/konley233/article/details/107198947 二、基于xml的事务管理 文件目录结构： 2.1 导入依赖 &
Spring事务管理详解与实例
"这篇博客详细介绍了Spring事务管理的相关知识，包括初步理解、事务的ACID特性、传播行为和事务配置等内容，并提供了实例分析。作者在撰写前参考了《spring in action》和其他网络资源，旨在全面解析Spring事务管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值