java事务传播特性_下面有关SPRING的事务传播特性，说法错误的是？

最新推荐文章于 2022-08-12 20:59:42 发布

清蒸星星清蒸星星

最新推荐文章于 2022-08-12 20:59:42 发布

阅读量812

点赞数

文章标签： java事务传播特性

本文链接：https://blog.csdn.net/weixin_36278287/article/details/114903155

版权

244

Spring的API设计很不错，基本上根据英文翻译就能知道作用:Required:必须的。说明必须要有事物，没有就新建事物。supports:支持。说明仅仅是支持事务，没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务，没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物，如果存在事物就挂起。never:绝不有事务。如果存在事物就抛出异常

发表于 2017-02-18 16:35:06

403

事务属性的种类：

传播行为、隔离级别、只读和事务超时

传播行为定义了被调用方法的事务边界。

传播行为意义

PROPERGATION_MANDATORY表示方法必须运行在一个事务中，如果当前事务不存在，就抛出异常

PROPAGATION_NESTED表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和

PROPAGATION_REQUIRED

看起来没什么俩样

PROPAGATION_NEVER表示方法不能运行在一个事务中，否则抛出异常

PROPAGATION_NOT_SUPPORTED表示方法不能运行在一个事务中，如果当前存在一个事务，则该方法将被挂起

PROPAGATION_REQUIRED表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务

PROPAGATION_REQUIRES_NEW表示当前方法必须运行在自己的事务中，如果当前存在一个事务，那么这个事务将在该方法运行期间被挂起

PROPAGATION_SUPPORTS表示当前方法不需要运行在一个是事务中，但如果有一个事务已经存在，该方法也可以运行在这个事务中

隔离级别

在操作数据时可能带来

个副作用，分别是脏读、不可重复读、幻读。为了避免这

中副作用的发生，在标准的

SQL

语句中定义了

种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在

spring

事务中提供了

种隔离级别来对应在

SQL

中定义的

种隔离级别，如下：

隔离级别意义

ISOLATION_DEFAULT使用后端数据库默认的隔离级别

ISOLATION_READ_UNCOMMITTED允许读取未提交的数据(对应未提交读)，可能导致脏读、不可重复读、幻读

ISOLATION_READ_COMMITTED允许在一个事务中读取另一个已经提交的事务中的数据(对应已提交读)。可以避免脏读，但是无法避免不可重复读和幻读

ISOLATION_REPEATABLE_READ一个事务不可能更新由另一个事务修改但尚未提交(回滚)的数据(对应可重复读)。可以避免脏读和不可重复读，但无法避免幻读

ISOLATION_SERIALIZABLE这种隔离级别是所有的事务都在一个执行队列中，依次顺序执行，而不是并行(对应可序列化)。可以避免脏读、不可重复读、幻读。但是这种隔离级别效率很低，因此，除非必须，否则不建议使用。

只读

如果在一个事务中所有关于数据库的操作都是只读的，也就是说，这些操作只读取数据库中的数据，而并不更新数据，那么应将事务设为只读模式(

READ_ONLY_MARKER

)

这样更有利于数据库进行优化

。

因为只读的优化措施是事务启动后由数据库实施的，因此，只有将那些具有可能启动新事务的传播行为

(PROPAGATION_NESTED

、

PROPAGATION_REQUIRED

、

PROPAGATION_REQUIRED_NEW)

的方法的事务标记成只读才有意义。

如果使用

Hibernate

作为持久化机制，那么将事务标记为只读后，会将

Hibernate

的

flush

模式设置为

FULSH_NEVER,

以告诉

Hibernate

避免和数据库之间进行不必要的同步，并将所有更新延迟到事务结束。

事务超时

如果一个事务长时间运行，这时为了尽量避免浪费系统资源，应为这个事务设置一个有效时间，使其等待数秒后自动回滚。与设

置“只读”属性一样，事务有效属性也需要给那些具有可能启动新事物的传播行为的方法的事务标记成只读才有意义。

发表于 2016-07-19 22:47:41

265

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

编辑于 2016-01-19 10:59:23

这是我在spring 3 API中看到的，然后自己翻译了一下，但是对于事务同步范围这个不是很懂，有知道的欢迎在下面评论，感谢！

PROPAGATION_REQUIRED

Support a current transaction;

create a new one if none exists.

支持一个当前事务;如果不存在，创建一个新的。

This is typically the default setting of a transaction

definition, and typically defines a transaction synchronization scope.

默认设置，后面的不懂

PROPAGATION_SUPPORTS

Support a current transaction;

execute non-transactionally if none exists.

支持当前事务；如果不存在当前事务则执行非事务。

PROPAGATION_NOT_SUPPORTED

Do not support a current

transaction; rather always execute non-transactionally.

不执行当前事务；而是总是执行非事务

PROPAGATION_REQUIRES_NEW

Create a new transaction,

suspending the current transaction if one exists.

创建一个新的事务，如果存在当前事务的话暂停(挂起)当前事务。

PROPAGATION_NESTED

Execute within a nested

transaction if a current transaction exists

如果当前存在事务的话，执行一个嵌套的事务

PROPAGATION_NEVER

Do not support a current

transaction; throw an exception if a current transaction exists.

不支持当前事务；如果存在当前事务则抛出一个异常

PROPAGATION_MANDATORY

Support a current transaction;

throw an exception if no current transaction exists.

支持当前事务；如果不存在当前事务则抛出一个异常

发表于 2015-04-07 23:37:02

PROPAGATION_SUPPORTS 从翻译上看--仅仅支持事务，没有就没有呗

PROPAGATION_REQUIRED 支持事务，如果有，就用着，没有的话就自己弄一个

PROPAGATION_REQUIRES_NEW 比较有个性，不管有没有，都自己弄一个(把原来的放在一边)

PROPAGATION_MANDATORY 强制必须要有事务，要是没有，就不开心了(抛出异常)

PROPAGATION_NOT_SUPPORTED 不支持事务，有就挂起来

PROPAGATION_NEVER 此处事务与狗不得入内，如果有，就赶出去(抛出异常)

编辑于 2017-11-17 10:38:33

编辑于 2019-10-21 20:57:05

答案：B

REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。

MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。

REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。

NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。

发表于 2016-07-08 16:10:12

其中PRPAGATION_REQUIRED与PROPAGATION_NESTED区别

1。

存在一个事务时，都会在该事务中一起运行，但是一个是要一起运行，一个是嵌套运行

嵌套的主要区别是可以单独提交或者回滚。嵌套事务回滚不会造成主事务自动回滚，但是主事务回滚将会导致两事务回滚！

编辑于 2017-05-13 13:53:27

支持当前事务的情况： TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。(mandatory：强制性)

不支持当前事务的情况： TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

其他情况： TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

发表于 2019-06-17 20:03:23

事务传播行为类型说明

PROPAGATION_REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。

PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY使用当前的事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 PROPAGATION_REQUIRED 类似的操作。

发表于 2016-10-27 15:03:19

B中 PROPAGATION_REQUIRED

如果当前方法产生了事务就用当前方法产生的事务，否则就创建一个新的事务

发表于 2015-03-07 19:09:20

事务(Transaction)

一、定义一组不可分割的操作单元，同时成功或同时失败

二、特点*4(ACID) 1. 原子性 Atomicity：一组操作不可分割，同时失败或成功

2. 一致性 Consistency：事务执行的前后数据库从一个一致性状态变到另一个一致性状态

3. 隔离性 Isolation：事务与事务之间相互之间不受干扰

4. 持久性 Durability：事务提交后对数据库造成的影响是持久的

三、问题*3 不考虑事务隔离性可能引发的问题：

1. 脏读：A事务读到B事务未提交的数据，导致读取数据前后不一致

2. 不可重复读：A事务前后读取到B事务提交更新或删除的数据，导致读取数据前后不一致

3. 幻读/虚读：A事务读取前后B事务插入了新数据，导致前后读取的前后总记录数不一致

四、Spring事务隔离级别*5 1. 默认 default：使用底层数据库的默认隔离级别

2. 读未提交 read uncommit：

3. 读已提交 read commit：可避免脏读

4. 可重复读 repeatable read：可避免脏读、不可重复读

5. 串行化 serializable：可避免脏读、虚读，解决不可重复读

五、Spring事务传播行为*7 1. Propagation.REQUIRED：支持当前事务，假设当前没有事务。就新建一个事务

2. Propagation.SUPPORTS：支持当前事务，假设当前没有事务，就以非事务方式运行

3. Propagation.MANDATORY：支持当前事务，假设当前没有事务，就抛出异常

4. Propagation.REQUIRES_NEW：新建事务，假设当前存在事务。把当前事务挂起

5. Propagation.NOT_SUPPORTED：以非事务方式运行。设当前存在事务，把当前事务挂起

6. Propagation.NEVER：以非事务方式运行，假设当前存在事务，则抛出异常

7. Propagation.NESTED：当前有事务，则在嵌套事务内执行。否则行为类似于第1条REQUIRED 转自：https://zhuanlan.zhihu.com/p/166514106

发表于 2020-12-01 10:05:05

事务属性的种类：传播行为、隔离级别、只读和事务超时 a) 传播行为定义了被调用方法的事务边界。传播行为意义 PROPERGATION_MANDATORY 表示方法必须运行在一个事务中，如果当前事务不存在，就抛出异常 PROPAGATION_NESTED 表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和 PROPAGATION_REQUIRED 看起来没什么俩样 PROPAGATION_NEVER 表示方法不能运行在一个事务中，否则抛出异常 PROPAGATION_NOT_SUPPORTED 表示方法不能运行在一个事务中，如果当前存在一个事务，则该方法将被挂起 PROPAGATION_REQUIRED 表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务 PROPAGATION_REQUIRES_NEW 表示当前方法必须运行在自己的事务中，如果当前存在一个事务，那么这个事务将在该方法运行期间被挂起 PROPAGATION_SUPPORTS 表示当前方法不需要运行在一个是事务中，但如果有一个事务已经存在，该方法也可以运行在这个事务中 b) 隔离级别在操作数据时可能带来 3 个副作用，分别是脏读、不可重复读、幻读。为了避免这 3 中副作用的发生，在标准的 SQL语句中定义了 4 种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在 spring 事务中提供了 5 种隔离级别来对应在 SQL 中定义的 4 种隔离级别，如下：隔离级别意义 ISOLATION_DEFAULT 使用后端数据库默认的隔离级别 ISOLATION_READ_UNCOMMITTED 允许读取未提交的数据(对应未提交读)，可能导致脏读、不可重复读、幻读 ISOLATION_READ_COMMITTED 允许在一个事务中读取另一个已经提交的事务中的数据(对应已提交读)。可以避免脏读，但是无法避免不可重复读和幻读 ISOLATION_REPEATABLE_READ 一个事务不可能更新由另一个事务修改但尚未提交(回滚)的数据(对应可重复读)。可以避免脏读和不可重复读，但无法避免幻读 ISOLATION_SERIALIZABLE 这种隔离级别是所有的事务都在一个执行队列中，依次顺序执行，而不是并行(对应可序列化)。可以避免脏读、不可重复读、幻读。但是这种隔离级别效率很低，因此，除非必须，否则不建议使用。 c) 只读如果在一个事务中所有关于数据库的操作都是只读的，也就是说，这些操作只读取数据库中的数据，而并不更新数据，那么应将事务设为只读模式( READ_ONLY_MARKER ) , 这样更有利于数据库进行优化。因为只读的优化措施是事务启动后由数据库实施的，因此，只有将那些具有可能启动新事务的传播行为 (PROPAGATION_NESTED 、 PROPAGATION_REQUIRED 、 PROPAGATION_REQUIRED_NEW) 的方法的事务标记成只读才有意义。如果使用 Hibernate 作为持久化机制，那么将事务标记为只读后，会将 Hibernate 的 flush 模式设置为 FULSH_NEVER, 以告诉 Hibernate 避免和数据库之间进行不必要的同步，并将所有更新延迟到事务结束。 d) 事务超时如果一个事务长时间运行，这时为了尽量避免浪费系统资源，应为这个事务设置一个有效时间，使其等待数秒后自动回滚。与设置“只读”属性一样，事务有效属性也需要给那些具有可能启动新事物的传播行为的方法的事务标记成只读才有意义。 Spring 支持 7 种事务传播行为： PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。 PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 PROPAGATION_REQUIRED 类似的操作。

编辑于 2019-03-14 23:39:45

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

发表于 2017-11-06 20:33:26

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

发表于 2017-09-17 21:06:06

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

发表于 2016-04-03 18:38:39

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

发表于 2016-03-03 17:15:32

PROPAGATION_REQUIRED

Support a current transaction;

create a new one if none exists.

支持一个当前事务;如果不存在，创建一个新的。

This is typically the default setting of a transaction

definition, and typically defines a transaction synchronization scope.

默认设置

PROPAGATION_SUPPORTS

Support a current transaction;

execute non-transactionally if none exists.

支持当前事务；如果不存在当前事务则执行非事务。

PROPAGATION_NOT_SUPPORTED

Do not support a current

transaction; rather always execute non-transactionally.

不执行当前事务；而是总是执行非事务

PROPAGATION_REQUIRES_NEW

Create a new transaction,

suspending the current transaction if one exists.

创建一个新的事务，如果存在当前事务的话暂停(挂起)当前事务。

PROPAGATION_NESTED

Execute within a nested

transaction if a current transaction exists

如果当前存在事务的话，执行一个嵌套的事务

PROPAGATION_NEVER

Do not support a current

transaction; throw an exception if a current transaction exists.

不支持当前事务；如果存在当前事务则抛出一个异常

PROPAGATION_MANDATORY

Support a current transaction;

throw an exception if no current transaction exists.

支持当前事务；如果不存在当前事务则抛出一个异常

发表于 2015-11-03 15:22:08

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

发表于 2021-02-20 15:34:35

PROPAGATION_REQUIRED：如果当前没有事务，就新建一个事务。如果已经存在了一个事务，加入到这个事务中。这是默认的事务传播行为.

PROPAGATION_NEVER: 以非事务方式执行操作，若当前存在事务，就抛出异常！

编辑于 2020-12-08 18:00:22

清蒸星星清蒸星星

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java事务传播特性_下面有关SPRING的事务传播特性，说法错误的是？

244Spring的API设计很不错，基本上根据英文翻译就能知道作用:Required:必须的。说明必须要有事物，没有就新建事物。supports:支持。说明仅仅是支持事务，没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务，没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物，如果存在事物就挂起。never...
复制链接

扫一扫