Spring (3) 声明式事务

原创 已于 2025-06-26 19:20:11 修改 · 676 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring

于 2025-06-23 00:50:15 首次发布

1 事务(transaction)

        事务是数据库的,并不是java的,一个事务中的所有操作,要么全部执行,要么全部不执行(回滚)

        mysql的事务只针对DML语句,而不能操作DDL   //例:①A表数据复制到B表②删除A表     如果①和②在同一个事务中,此时发生错误①(DML语句)能回滚②(DDL语句)不能回滚,导致的结果就是B表没有数据A表还被删除成功了

        事务的4大特性:

                (A) 原子性: 十五中的操作要么都生效,要么都不生效

                (C) 一致性: 事务执行前后,数据库中定义的约束,业务规则等保持不变

                (I)  隔离性: 并发访问数据库时,多个事物之间互不影响

                (D) 持久性: 如果事务被成功提交,数据会持久保存在数据库

                (原子性、一致性、持久性都是单事务; 隔离性是多事务并发)

        脏读: 读取到另一个事务未提交的数据

        不可重复读: 受其它事务update的干扰(期望是操作修改之前的数据)

        虚读/幻读: 读取不到其它事务的insert/delete,但操作数据时提示"数据异常"等问题

2 事务传播行为

事务传播类型传播特性
REQUIRED当前线程有事务就加入当前线程,没有就新建事务
SUPPORTS支持当前事务(当前线程有事务就加入当前事务,没有就以非事务执行)
MANDATORY当前线程有事务就加入当前事务,没有就抛异常
REQUIRES_NEW不管当前线程有没有事务都新建一个事务,新事务与之前事务没有嵌套关系,之前的事务挂起
NOT_SUPPORTED以非事务方式执行
NEVER以非事务方式执行,如果当前存在事务就抛异常
NESTED(Spring提供的一个特殊变量)如果当前有事务,则创建一个嵌套事务;如果当前无事务,则新建事务

2.1 REQUIRED

        只要将方法中的业务代码的异常捕获处理了,就不会回滚

@RequestMapping("/transactionalTest.do")
@Transactional
public Result aaa() {
    guardNetDao.update(guardNetUpdateWrapper);
	try {
		int i = 1 / 0;
	} catch (Exception e) {
		System.out.println("aaa异常了");
	}
	transactionB.bbb();
	transactionC.ccc();
}


@Transactional
public void bbb() {
	alWindowDao.update(alWindowUpdateWrapper);
	try {
		int i = 1 / 0;
	} catch (Exception e) {
		System.out.println("bbb异常了");
	}
}


@Transactional
public void ccc() {
	alWindowModelsDao.update(alWindowModelsUpdateWrapper);
	try {
		int i = 1 / 0;
	} catch (Exception e) {
		System.out.println("ccc异常了");
	}
}

                都不回滚,事务正常执行

        在方法外捕获异常,如果被捕获的方法有事务,回滚; 如果被捕获的方法没有事务,不会回滚

@RequestMapping("/transactionalTest.do")
@Transactional
public Result aaa() {
	guardNetDao.update(guardNetUpdateWrapper);
	transactionB.bbb();
	try {
		transactionC.ccc();
	} catch (Exception e) {
		System.out.println("ccc方法异常了");
	}
}


@Transactional
public void bbb() {
	alWindowDao.update(alWindowUpdateWrapper);
}


@Transactional
public void ccc() {
	alWindowModelsDao.update(alWindowModelsUpdateWrapper);
	int i = 1 / 0;
}

                事务全部回滚

@RequestMapping("/transactionalTest.do")
@Transactional
public Result aaa() {
	guardNetDao.update(guardNetUpdateWrapper);
	transactionB.bbb();
	try {
		transactionC.ccc();
	} catch (Exception e) {
		System.out.println("ccc方法异常了");
	}
}


@Transactional
public void bbb() {
	alWindowDao.update(alWindowUpdateWrapper);
}


public void ccc() {
	alWindowModelsDao.update(alWindowModelsUpdateWrapper);
	int i = 1 / 0;
}

                事务全部不回滚

@RequestMapping("/transactionalTest.do")
public Result aaa() {
	guardNetDao.update(guardNetUpdateWrapper);
	transactionB.bbb();
	try {
		transactionC.ccc();
	} catch (Exception e) {
		System.out.println("ccc方法异常了");
	}
}


@Transactional
public void bbb() {
	alWindowDao.update(alWindowUpdateWrapper);
}


@Transactional
public void ccc() {
	alWindowModelsDao.update(alWindowModelsUpdateWrapper);
	int i = 1 / 0;
}

                aaa和bbb正常执行,ccc回滚

2.2 REQUIRES_NEW

        内层事务结束,内层就提交了,不用等外层一起提交

        外层报错回滚,不影响内层

        内层报错回滚,外层try-catch了内层的异常,外层不会回滚

        内层报错回滚,外层没有try-catch内层的异常,外层回滚

2.3 NESTED

        内层嵌套事务结束,要等外层事务一起提交

        外层回滚,内层嵌套事务也会滚

        内层嵌套事务回滚,不影响外层事务   //内层回滚不影响外层是有前提的:在外层方法中将内层的异常捕获处理,否则内外都回滚

3 声明式事务

3.1 Spring声明式事务

        对应声明式事务的是"编程式事务",通过代码的方式实现事务,事务的"开启,提交,回滚"等操作都由代码手动完成

        底层原理是利用了AOP,声明式事务通过配置方式(XML配置,注解配置)管理数据库事务,核心特征是事务控制与业务逻辑解耦

        (1) 添加依赖

                添加spring-boot-starter依赖

        (2) 配置事务管理器(注入数据源),开启Spring声明式事务的注解支持

                在配置类添加@EnableTransactionManagement

                (在SpringBoot中默认开启)

        (3) 在类/方法(方法优先级更高)上添加@Transactional注解

/**
 * readOnly=true  只读:只能查询,不能增删改
 * timeout=10  超时(秒):回滚  默认-1(永不超时)
 * 回滚策略:设置哪些异常回滚,哪些异常不回滚
 *      设置回滚:rollbackFor={Exception.class,RuntimeException.class}
 *              rollbackForClassName={"全限定类名"}
 *      设置不回滚:noRollbackFor={......}
 *                noRollbackForClassName={.....}
 * isolation  事务隔离级别:解决"读的问题"
 *      =Isolation.DEFAULT使用数据库的默认隔离级别
 *      =Isolation.READ_UNCOMMITTED
 *      =Isolation.READ_COMMITTED    (oracle默认,有"不可重复读")
 *      =Isolation.REPEATABLE_READ    (mysql默认,有"虚读/幻读")
 *      =Isolation.SERIALIZABLE
 * propagation  事务传播行为:事务之间的调用(例如:A调用B,那么要使用哪个的事务)
 *      Propagation.REQUIRED(默认)
 *      Propagation.SUPPORTS
 *      Propagation.MANDATORY
 *      Propagation.REQUIRES_NEW
 *      Propagation.NOT_SUPPORTED
 *      Propagation.NEVER
 *      Propagation.NESTED
 */
@Transactional(readOnly = false, timeout = 10, rollbackFor = RuntimeException.class, isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
public void aaa() {
	userDao.aaa();
}

3.2 生效范围

        被@Transactional标记的方法,在方法开始和结束,分别执行开启,提交,(异常)回滚事务,只要方法从开始到结束没有异常(即便有异常,但在方法中将异常捕获处理了),就不会回滚

        标记方法的异常在上游方法中被捕获处理了,标记方法也会回滚,因为针对标记方法的AOP已经捕获到异常了,因此触发了回滚

3.3 内部调用@Transactional不生效

        Spring通过AOP实现事务管理,当容器扫描到方法上有@Transactional时,会为目标生成一个代理类,此代理类的所有其他方法都是继承的原来的bean,当@Transactional标注的方法被调用时,实际上是由代理类来调用的,而在此代理类的此方法中的内部调用的同一个类其他方法都是调用的继承原bean的方法,因此当内部调用的方法即使被@Transaction标记了,也不会生效

spring事务PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW
qq_33271461的博客
02-08 1210
spring事务PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW
spring，springboot之事务（事务传播机制详解、嵌套事务）
qq_35493807的博客
04-27 1万+
spring，springboot之事务（事务传播机制、嵌套事务、事务隔离机制详解）
spring 嵌套事务(Nested Transaction) 和新建事务测试
ahujyy的专栏
05-31 967
查询Nested Transaction细节时，经典例子 serviceA 调用 serviceB，当SeviceB事务传播属性为NESTED时，serviceA 只要catch住了Exception就能保证调用serviceB之前的操作提交而不受ServiceB异常的影响，但是如果 REQUIRES_NEW时，serviceA和serviceB相对独立，serviceB有异常会不影响serv...
Spring Nested事务简单案例
11-22
这里是Spring的一个Nested事务的代码及数据库文件,因为NESTED资源很少,这里作出了一个通俗易懂的 让需要者下载。
spring事务问题(三) - 嵌套事务(NESTED)
面朝大海，春暖花开
12-26 6624
spring事务问题(三) - 嵌套事务(NESTED) 嵌套事务 |--主事务开始 | ------------嵌套事务1 | ------------嵌套事务2 |--主事务结束 现有两个类: @Component public class UserManager { @Autowired private UserDao userDao; @Transactional(propagation = Propagation.NESTED) public vo
Spring的声明式事务在多线程的场景当中会失效，解决方案
最新发布
04-12
在使用Spring框架进行企业级开发时，声明式事务管理是一种非常便捷的事务处理方式，它通过AOP（面向切面编程）技术将事务的管理与业务逻辑代码分离，从而简化了事务的配置和管理。然而，在多线程环境下，声明式事务...
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
Spring声明式事务和@Aspect的拦截顺序问题的解决
08-27
Spring 声明式事务和 @Aspect 的拦截顺序问题的解决 Spring 框架中，声明式事务和 @Aspect 都可以用于实现Aspect-Oriented Programming（面向方面编程），但是它们的拦截顺序问题往往会导致很多问题。本文将详细...
Spring的编程式事务和声明式事务详解
08-29
Spring框架提供了两种事务管理机制：编程式事务和声明式事务。编程式事务是通过编写代码来管理事务，声明式事务则是通过配置文件或注解来管理事务。 事务属性 Spring的事务属性是通过TransactionDefinition接口...
Spring声明式事务源码分析
他叫阿来
07-18 1372
它实现了SmartInstantiationAwareBeanPostProcessor，说明这是⼀个后置处理器，⽽且跟spring AOP 开启@EnableAspectJAutoProxy 时注册的 AnnotationAwareAspectJProxyCreator实现的是同⼀个接⼝，所以说，声明式事务是 springAOP 思想的⼀种应⽤。：在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务。：通过xml或者注解配置的⽅式达到事务控制的⽬的，叫做声明式事务。上述组件如何关联起来的？
spring的事务传播行为之nested和requires_new
jingchun1的博客
01-13 1434
传播行为是嵌套事务，它会创建一个保存点（Savepoint）并在需要时回滚到该保存点，但如果外层事务回滚，它会回滚到整个事务的起点，包括内层的嵌套事务。requires_new: 内层和外层是俩个毫不相关的事务，外层是否回滚，取决于内层抛出后，外层是否捕获异常。nested： 内外层是一个嵌套间的关系，当内层回滚，外层的回滚取决于是否捕获异常。如果外层事务顺利提交，而内层事务发生异常，则只会回滚内层事务，而外层事务不受影响。具体来说，如果外层事务发生了异常并回滚，内层事务也会被回滚。
脱离 Spring 实现复杂嵌套事务，之四（NESTED - 嵌套事务）
weixin_34405332的博客
02-15 631
为什么80%的码农都做不了架构师？>>> ...
Spring的声明式事务模型
yygr的博客
03-25 281
https://zhuanlan.zhihu.com/p/41864893 组内每周都有技术分享，轮着来，人人有份。 上次分享了Spring的统一事务模型，这次聊聊Spring的声明式事务模型。 和上次一样，把屁屁踢整理成文稿，和诸君共食。 难度一般，老少咸宜。 关注微信公众号Bridge4You，回复Spring事务，即可获取这两次分享的keynote和ppt。 什么是Spring的声明式事务 声明式事务，其实就是我们常用的@Transactional注解。 加了个注解，马上就有了事务
【spring】事务传播属性REQUIRED_NESTED的原理
morris
04-21 909
传统事务中回滚点的使用 package com.morris.spring.demo.jdbc; import java.sql.*; /** * 传统JDBC中回滚点的使用 */ public class TraditionSavePointDemo { public static void main(String[] args) throws SQLException { String url = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=t
spring 事务传播REQUIRED 与 NESTED的区别
FREEDOM
05-12 5424
NESTED 似乎与REQUIRED 是一样的，但是他们是不同的。 若 关于spring事务传播机制的解释 播行为 意义 PROPAGATION_REQUIRES 表示当前方法必须在一个事务中运行。如果一个现有事务正在进行中，该方法将在那个事务中运行，否则就要开始一个新事务。 PROPAGATION_SUPPORTS 表示当前方法不需要事务性上下文，但是如果有一个事务已经在运行的话，它也可以在这个事务里运行。 PROPAGATION_MANDATORY ...
Spring 事务七大传播机制 —— REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED
流华追梦的专栏
03-14 4659
首先简单了解一下 Spring 中事务传播行为是什么？听起来很高端，但是真正用起来的时候，稍有不慎，就会让自己陷入困境之中，所以在使用之前，我们必须要十分耐心认真的学习它。从名字理解起来，事务传播行为，既然为传播就肯定发生在两个实体之间，否则单个实体又如何发生行为呢。通俗点讲就是“一个巴掌拍不响”。下面是定义。事务传播行为主要用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的事务中，该事务如何传播。这个概述可能不好理解，换句话就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
Spring事务系列 三
weixin_41965831的博客
04-10 933
当多个事务存在调用关系，事务在这些方法间是如何传播的？本文介绍Spring事务的传播机制。提示：以下是本篇文章正文内容，下面案例可供参考本文介绍了Spring事务的传播机制。
【spring】spring 的事务(transaction) 四 嵌套事务PROPAGATION_NESTED
热门推荐
m0_45406092的博客
08-08 1万+
文章目录1. 什么是嵌套事务PROPAGATION_NESTED2. PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别2.1 验证PROPAGATION_REQUIRES_NEW内层事务执行完就立即提交2.2 验证PROPAGATION_NESTED 内层事务执行完未立即提交2.3 验证PROPAGATION_NESTED 内层事务回滚 相关文章 spring 的事务(transaction) 一 基础概念介绍 spring 的事务(transaction) 二
SPRING 事务控制
woi123的专栏
06-08 507
在 SPRING 中一共定义了六种事务传播属性 PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 PROPAGAT...
Spring.NET声明式事务管理案例详解
3. **小示例**：说明这是一个入门级别的示例，适用于初学者快速理解如何使用Spring.NET进行声明式事务管理。 ### 描述知识点 描述中提到“有完整的配置，以及测试”，涉及的知识点包括： 1. **完整配置**：指在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值