Spring事务（4种特性、7种传播行为，5种隔离级别）

﹏ヽ暗。殇╰゛Y 2021-12-11 10:21 181阅读 0赞

转载自[https://blog.csdn.net/hcmony/article/details/77850183][https_blog.csdn.net_hcmony_article_details_77850183]

--------------------

# Spring事务 #

事务是逻辑上的一组操作。组成这组操作的各个逻辑单元必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。

# 事务有四个特性：ACID #

1.  原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
2.  一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
3.  隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
4.  持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

![20190708222321433.png][]

# 1 传播行为 #

事务的第一个方面是传播行为（propagation behavior）。当事务方法**被另一个事务方法调用时**，必须指定**事务应该如何传播**。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring定义了七种传播行为：

<table style="margin-left:-.6pt;"> 
 <tbody> 
 <tr> 
 <td style="width:152.2pt;"> 传播行为 </td> 
 <td> 含义 </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_REQUIRED </td> 
 <td> 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务 </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_SUPPORTS </td> 
 <td> 表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行 </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_MANDATORY </td> 
 <td> 表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常 </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_REQUIRED_NEW </td> 
 <td> 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_NOT_SUPPORTED </td> 
 <td> 表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_NEVER </td> 
 <td> 表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常 </td> 
 </tr> 
 <tr> 
 <td style="width:152.2pt;"> PROPAGATION_NESTED </td> 
 <td> 表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务 </td> 
 </tr> 
 </tbody> 
</table>

（下面是通俗讲解）

当**事务方法**被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring定义了七种传播行为：

1》PROPAGATION\_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

2》PROPAGATION\_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION\_SUPPORTS与不使用事务有少许不同。

3》PROPAGATION\_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

4》PROPAGATION\_REQUIRES\_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

我把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。Ts2是否成功并不依赖于 ts1。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了 methodB之外的其它代码导致的结果却被回滚了。使用PROPAGATION\_REQUIRES\_NEW,需要使用 **JtaTransactionManager**作为事务管理器。

5》PROPAGATION\_NOT\_SUPPORTED 总是**非事务地执行，并挂起任何存在的事务**。使用PROPAGATION\_NOT\_SUPPORTED,也需要使用**JtaTransactionManager**作为事务管理器。

6》PROPAGATION\_NEVER 总是**非事务地执行**。表示**当前方法**不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常。（当事务方法被另一个事务方法调用时）如果存在一个活动事务，则抛出异常。

7》PROPAGATION\_NESTED如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION\_REQUIRED 属性执行。

这是一个嵌套事务,**使用JDBC 3.0驱动时**,**仅仅支持DataSourceTransactionManager作为事务管理器**。需要JDBC 驱动的java.sql.Savepoint类。

有一些JTA的事务管理器实现可能也提供了同样的功能。使用PROPAGATION\_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;而 nestedTransactionAllowed属性值默认为false。

嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

### 注意： ###

1》PROPAGATION\_NESTED 与PROPAGATION\_REQUIRES\_NEW的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用 PROPAGATION\_REQUIRES\_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要JTA事务管理器的支持。

2》使用PROPAGATION\_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager使用savepoint支持PROPAGATION\_NESTED时，需要JDBC 3.0以上驱动及1.4以上的JDK版本支持。其它的JTA TrasactionManager实现可能有不同的支持方式。

3》PROPAGATION\_REQUIRES\_NEW 启动一个新的, 不依赖于环境的 “内部” 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行。

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

5》由此可见, PROPAGATION\_REQUIRES\_NEW 和 PROPAGATION\_NESTED 的最大区别在于, PROPAGATION\_REQUIRES\_NEW 完全是一个新的事务, 而 PROPAGATION\_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.

6》PROPAGATION\_REQUIRED应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

# **2 隔离级别** #

事务的第二个维度就是隔离级别（isolation level）。隔离级别定义了**一个事务可能受**其他并发事务 **影响****的程度**。

## 并发事务引起的问题 ##

在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务。并发虽然是必须的，但可能会导致以下的问题：

> 1.  脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务**改写但尚未提交的数据**时。如果改写在稍后被回滚了，那么第一个事务获取的数据就是无效的。
> 2.  不可重复读（Nonrepeatable read）——不可重复读发生在一个事务**执行相同的查询两次或两次以上，但是每次都得到不同的数据**时。这通常是因为**另一个并发事务在两次查询期间进行了更新**。
> 3.  幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着**另一个并发事务（T2）插入了一些数据时**。在随后的查询中，第一个事务（T1）就会发现**多了一些原本不存在的记录**。

### **不可重复读与幻读的区别:** ###

1.  不可重复读的重点是**修改**：同样的条件, 你读取过的数据, 再次读取出来发现值不一样了
2.  幻读的重点在于**新增或者删除**：同样的条件, 第1次和第2次读出来的**记录数不一样****。**
3.  从总的结果来看, 似乎不可重复读和幻读都表现为两次读取的结果不一致。但如果你从控制的角度来看, 两者的区别就比较大。 对于前者, 只需要锁住**满足条件的记录**。 对于后者, 要锁住**满足条件及其相近的记录**。

<table style="margin-left:-.6pt;"> 
 <tbody> 
 <tr> 
 <td style="width:187.5pt;"> 隔离级别 </td> 
 <td style="width:522pt;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="width:187.5pt;"> ISOLATION_DEFAULT </td> 
 <td style="width:522pt;"> 使用后端数据库默认的隔离级别 </td> 
 </tr> 
 <tr> 
 <td style="width:187.5pt;"> ISOLATION_READ_UNCOMMITTED </td> 
 <td style="width:522pt;"> 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读 </td> 
 </tr> 
 <tr> 
 <td style="width:187.5pt;"> ISOLATION_READ_COMMITTED </td> 
 <td style="width:522pt;"> 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生 </td> 
 </tr> 
 <tr> 
 <td style="width:187.5pt;"> ISOLATION_REPEATABLE_READ </td> 
 <td style="width:522pt;"> 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生 </td> 
 </tr> 
 <tr> 
 <td style="width:187.5pt;"> ISOLATION_SERIALIZABLE </td> 
 <td style="width:522pt;"> 最高的隔离级别，完全服从ACID的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的 </td> 
 </tr> 
 </tbody> 
</table>

对上表的一些解释如下:

1》ISOLATION\_DEFAULT 使用后端数据库默认的隔离级别。（ISOLATION \[ˌaɪsəˈleɪʃn\] 隔离）

2》ISOLATION\_READ\_UNCOMMITTED 最低的隔离级别，允许读取**尚未提交的数据变更**，可能会导致脏读、幻读或不可重复读

3》ISOLATION\_READ\_COMMITTED 允许读取**并发事务已经提交的数据**，可以**阻止脏读**，但是**幻读**或**不可重复读**仍有可能发生。（脏读：发生在 一个事务读取了，另一个事务改写了但尚未提交到数据库的数据时。因为**改写没有提交到数据库，所以可能会回滚**。导致第一个事务读到的值无效）

4》ISOLATION\_REPEATABLE\_READ 一个事务中，对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改。可以**阻止脏读和不可重复读**，但**幻读仍有可能发生****（****不可重复读：一个事务中执行多次相同的查询时，读取到的值不同，重点在于修改update****）**

**5》**ISOLATION\_SERIALIZABLE 最高的隔离级别，完全服从ACID的隔离级别，确保**阻止脏读、不可重复读以及幻读**，也是**最慢的事务隔离级别**，因为它通常是通过**完全锁定****事务相关的数据库表**来实现的。（幻读：一个事务中，2次或多次执行相同的查询时，得到的结果的行数不一样。重点在于增加insert和删除delete）

# 3 只读 #

事务的第三个特性是它是否为只读事务。如果事务只对后端的[**数据库**][Link 1]进行该操作，数据库可以利用事务的只读特性来进行一些特定的优化。通过将事务设置为只读，你就可以给数据库一个机会，让它应用它认为合适的优化措施。

# **4 事务超时** #

为了使应用程序很好地运行，事务不能运行太长的时间。因为事务可能涉及对后端数据库的锁定，所以长时间的事务 会不必要地占用数据库资源。事务超时就是事务的一个定时器，在特定时间内事务如果没有执行完毕，那么就会自动回滚，而不是一直等待其结束。

### **5 回滚规则** ###

事务五边形的最后一个方面是一组规则，这些规则定义了哪些异常会导致事务回滚，而哪些不会。默认情况下，事务只有遇到运行期异常时才会回滚，而在遇到检查型异常时不会回滚（这一行为与EJB的回滚行为是一致的）   
但是你可以声明事务在遇到特定的检查型异常时像遇到运行期异常那样回滚。同样，你还可以声明事务遇到特定的异常不回滚，即使这些异常是运行期异常。

# **编程式事务** #

Spring提供了对编程式事务和声明式事务的支持。编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。

简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。（编程式事务放到了代码里。声明式事务放在AOP里面）

[https_blog.csdn.net_hcmony_article_details_77850183]: https://blog.csdn.net/hcmony/article/details/77850183
[20190708222321433.png]: /images/20211211/28a50fb2dc12429dbb0bcd0c5fe2d299.png
[Link 1]: http://lib.csdn.net/base/mysql