详解spring事务属性

事务是什么？

事务像1个原子，1个事务中的操作要么全部执行，要么就不要执行，它就应当是执行的最小单元；

事务的特点

* atomicity 原子性，事务是1个不可分割的工作单元

* consistency 一致性，事务所完成的工作后，各有关系的部分应当是协调一致的，就像买东西一样，事务应当包含付款和取货，而不能只包含其中1个；

* isolation 隔离性，1个事务执行期间不能受其它事务干扰，即 1个事务的操作和使用的数据对同时发生的其它事务应当是隔离的，即避免资源使用的冲突；

*durability 永久性，事务成功完成后，它产生的影响就不再回滚了；

关键字: spring事务

Spring事务－（1）2008-07-25 11:37Spring事务－（1）Spring的事务管理是其非常重要的一个方

面，Spring的应用主要集中在Ioc/AOP/DAO/事务四个方面。这部分内容比较抽象，需要花费大篇幅来写。

一、事务控制的基本知识不管是什么事务，必须先对数据库的事务概念有个明确认识才行。首先先简单介

绍下数据库的事务。事务的概念：事务是一组原子性操作的工作单元，这组工作单元要么执行成功，要么

不成功。事务有四个属性--原子性、一致性、独立性和持久性（CAID），所有这些方面都是依靠事务资源

去维护。事务隔离：SQL 标准用三个必须在并行的事务之间避免的现象定义了四个级别的事务隔离。这些

不希望发生的现象是：脏读（dirty reads）一个事务读取了另一个未提交的并行事务写的数据。不可重

复读（non-repeatable reads）一个事务重新读取前面读取过的数据，发现该数据已经被另一个已提交

的事务修改过。幻读（phantom read）一个事务重新执行一个查询，返回一套符合查询条件的行，发现

这些行因为其他最近提交的事务而发生了改变。这四种隔离级别和对应的行为如下表：

隔离级别脏读（Dirty Read）不可重复读（NonRepeatable Read）幻读（Phantom

Read）

读未提交（Read uncommitted）可能可能可能读已提交（Read committed）不可能可能可能

可重复读（Repeatable read）不可能不可能可能

可串行化（Serializable ）不可能不可能不可能Spring事务包中的TransactionDefinition接口有对应的隔离级别的定义。高清楚以上的概念，才能更好

理解Spring的事务管理。二、从编程的角度认识事务和数据库事务概念几乎完全一样：事务是一种机制，

把组成的多个操作视为一个操作单元进行处理，这个单元要么全部执行成功，要么全部不执行。在事务中

，涉及的操作可能依赖于很多不同的数据库和服务器。从程序角度考虑，事务可以分为两大类：一种是本

地事务，一种是全局事务（也叫分布式事务）。本地事务：是针对某个独立的事务资源（如JDBC）操作的

事务。全局事务：是协同或横跨多个资源（如JDBC连接、数据库等）操作的事务（上下文），多个资源协

作是由事务管理器来完成的。事务源：是可以绑定事务操作的资源。事务的概念最初来自数据库的操作，

事务的资源也仅限于数据库。但编程中的事务，事务源很广泛，不但可以包含数据库，还可以包含打印机

等。本地事务和全局事务有很大的区别：全局事务的控制非常复杂，全局事务使用两阶段提交协议(2PC)来

提交资源源的变化。阶段一请求所有资源准备实现改变；阶段二请求做实际的改变。

全局事务ID（XID）是用于跟踪所有分布式事务相关的改变。全局事务的实现需要由专门的应用服务器或者

容器去实现。在Java中，可以借助实现了Java Transaction API的库来进行全局事务控

制。JDBC与JTAJDBC是Java database connectivity 的缩写，意思是Java数据库连接。一般本地事务是

与一个数据库连接相关的，因此Java中常称本地事务为JDBC事务。JDBC本身提供了简单的本地事务控制，

可以满足针对一个JDBC连接事务的需求。JTA是Java Transaction API的缩写，意思是Java 事务API，这

是一种组复杂事务控制接口，这组接口作为J2EE规范暴露给容器开发商，一般都由J2EE 容器来实

现。Spring很牛，也实现了这组API，使得任何应用使用JTA事务变得更容易。三、认识Spring的事务包的

APISpring对事务的控制的API全部位于org.springframework.transaction包下面，其中出去异常定义

的类外，仅有四个接口，这四个接口是Spring操作事务的核心，下面一一介

绍：org.springframework.transactionInterfaces PlatformTransactionManager

SavepointManager

TransactionDefinition

TransactionStatus

Exceptions :

CannotCreateTransactionException

HeuristicCompletionException

IllegalTransactionStateException

InvalidIsolationLevelException

InvalidTimeoutException

NestedTransactionNotSupportedException

NoTransactionException

TransactionException

TransactionSuspensionNotSupportedException TransactionSystemException

TransactionTimedOutException

TransactionUsageException

UnexpectedRollbackException

要搞明白Spring事务控制的原理，必须理解上面四个接口的含义，下面一一介绍之。

1、PlatformTransactionManager是一个事务管理平台，该接口有许多具体的事务实现类，例

如DataSourceTransactionManager, HibernateTransactionManager, JdoTransactionManager,

JmsTransactionManager, JpaTransactionManager, JtaTransactionManager,

TopLinkTransactionManager, WebLogicJtaTransactionManager 等等，通过实现此接口，

Spring可以

管理任何实现了这些接口的事务。开发人员也可以使用统一的编程模型来控制管理事务。此

接口中有三个

方法：void commit(TransactionStatus status) Commit the given transaction,

with

regard to its status. 监视事务状态，并提交一个事务。TransactionStatus

getTransaction(TransactionDefinition definition) Return a currently

active

transaction or create a new one, according to the specified propagation behavior.

根据事务的隔离级别和传播行为，返回当前活动的事务或者产生一个新的事务。void

rollback(TransactionStatus status) Roll back the given transaction. 回滚给定的事务。

2、SavepointManager事务回滚点管理接口，提供创建、释放回滚点，或者回滚到指定的回

滚点。方法摘

要：Object createSavepoint() Create a new savepoint. 创建一个

新的回滚点

。void releaseSavepoint(Object savepoint) Explicitly release the given

savepoint. 释放一个给定的回滚点。void rollbackToSavepoint(Object

savepoint)

Roll back to the given savepoint. 回滚到给定的回滚点。

3、TransactionDefinition这个接口的作用就是定义事务的名称、隔离级别、传播行为、

超时时间长短、

只读属性等。字段摘要：(因为是接口，里面都是int常量，即public static final类型

的，很多，我就

只写常量的名字和含义)这些接口分两组，分别是事务隔离级别和事务传播行为。//事务隔离级别（数据库

级别的知识） TransactionDefinition.ISOLATION_DEFAULT使用底层数据库默认隔离级

别。TransactionDefinition.ISOLATION_READ_UNCOMMITTED 读未提交最低隔离等级，允许事务读取其

他并行的事务还没有提交的数据，会发生脏读（dirty reads）、不可重复读（non-repeatable reads）

、幻读（phantom read）等问题。TransactionDefinition.ISOLATION_READ_COMMITTED 读已提交允许

事务读取其他并行的事务已经提交的数据，可以防止脏读问

题。TransactionDefinition.ISOLATION_REPEATABLE_READ 可重复读保证了一个事务不会修改已经由另

一个事务读取但未提交（回滚）的数据。TransactionDefinition.ISOLATION_SERIALIZABLE 可串行化

所有事务都严格隔离，各个事务顺序执行。很容易发生死锁。//事务传播行

为TransactionDefinition.PROPAGATION_REQUIRED支持现有的事务，如果没有则新建一个事

务。TransactionDefinition.PROPAGATION_SUPPORTS支持现有的事务，如果没有则以非事务状态运行。

TransactionDefinition.PROPAGATION_MANDATORY支持现有事务，如果没有则抛出异

常。TransactionDefinition.PROPAGATION_REQUIRES_NEW总是发起一个新事务。如果当前已存在一个事

务，则将其挂起。TransactionDefinition.PROPAGATION_NOT_SUPPORTED不支持事务，总是以非事务状

态运行，如果当前存在一个事务，则将其挂起。TransactionDefinition.PROPAGATION_NEVER 不支持事务

，总是以非事务状态运行，如果当前存在一个事务，则抛出异

常。TransactionDefinition.PROPAGATION_NESTED如果石阡已经存在一个事务，则以嵌套

事务的方式运

行，如果当前没有事务，则创建一个新事务。方法摘要：int getIsolationLevel()

Return

the isolation level. 返回事务的隔离级别。String getName()

Return the

name of this transaction. 返回事务的名字。int getPropagationBehavior() Return the propagation behavior. 返回事务的是传播行为。int getTimeout() Return the transaction timeout. 返回事务的超时时间。boolean isReadOnly()

Return whether to optimize as read-only transaction. 返回是否（优化为）

只读属性

。

4、TransactionStatus 这个接口的作用就是获取事务的状态（回滚点、是否完成、是否新

事物、是否回

滚）属性，还可以进行事务rollback-only的设置。方法摘要：boolean hasSavepoint()

Return whether this transaction internally carries a savepoint, i.e. has been

created

as nested transaction based on a savepoint. 判断这个事务是否有一个内在

的回滚

点（savepoint），即创建为基于回滚点的嵌套事务。boolean isCompleted()

Return

whether this transaction is completed, that is, has already been committed or rolled

back. 判断这个事务是否完成，也就是已经提交或者回滚。boolean

isNewTransaction()

Return if the transaction is new, else participating in an existing

transaction.

判断一个事物是否为新事务，或者是这个事务参与到一个已经存在的事务里面。

boolean

isRollbackOnly() Return if the transaction has been set rollback-only.

判断这个事务是否已经设置了rollback-only。void setRollbackOnly() Set

the

transaction rollback-only. 设置这个事务rollback-only。

详解spring事务属性

Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得

连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理

大量的try…catch…finall y代码。

我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由

事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划

分时，需要进行事务定义，也就是配置事务的属性。

Spring在TransactionDefinition接口中定义这些属性,以供

PlatfromTransactionManager使用, PlatfromTransactionManager是spring事务管理的核

心接口。

Java代码

1.TransactionDefinition

2.public interface TransactionDefinition {

3. int getPropagationBehavior();

4. int getIsolationLevel();

5. int getTimeout();

6. boolean isReadOnly();

7.}

getTimeout()方法，它返回事务必须在多少秒内完成。

isReadOnly(),事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读

的。

getIsolationLevel()方法返回事务的隔离级别，事务管理器根据它来控制另外一个事务可

以看到本事务内的哪些数据。

在TransactionDefinition接口中定义了五个不同的事务隔离级别

ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库

默认的事务隔离级别.另外四个与JDBC的隔离级别相对应

ISOLATION_READ_UNCOMMITTED这是事务最低的隔离级别，它充许别外一个事务可以看到这

个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

例如:

Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务

Java代码

1.Connection con1 = getConnection();

2.con.setAutoCommit(false);

3.update employee set salary = 8000 where empId ="Mary";

与此同时，Mary正在读取自己的工资

Java代码

1.Connection con2 = getConnection();

2.select salary from employee where empId ="Mary";

https://www.360docs.net/doc/812877340.html,mit();

Mary发现自己的工资变为了8000，欢天喜地！

而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000

Java代码

1.//con1

2. con1.rollback();

像这样,Mary记取的工资数8000是一个脏数据。

ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。

ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。

在事务1中，Mary 读取了自己的工资为1000,操作并没有完成

Java代码

1.con1 = getConnection();

2.select salary from employee empId ="Mary";

在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.

Java代码

1.con2 = getConnection();

2.update employee set salary = 2000;

https://www.360docs.net/doc/812877340.html,mit();

在事务1中，Mary 再次读取自己的工资时，工资变为了2000

Java代码

1.//con1

2.select salary from employee empId ="Mary";

在一个事务中前后两次读取的结果并不致，导致了不可重复读。

使用ISOLATION_REPEATABLE_READ可以避免这种情况发生。

ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

目前工资为1000的员工有10人。

事务1,读取所有工资为1000的员工。

Java代码

1.con1 = getConnection();

2.Select * from employee where salary =1000;

共读取10条记录

这时另一个事务向employee表插入了一条员工记录，工资也为1000

Java代码

1.con2 = getConnection();

2.Insert into employee(empId,salary) values("Lili",1000);

https://www.360docs.net/doc/812877340.html,mit();

事务1再次读取所有工资为1000的员工

Java代码

1.//con1

2.select * from employee where salary =1000;

共读取到了11条记录，这就产生了幻像读。

ISOLATION_SERIALIZABLE能避免这样的情况发生。但是这样也耗费了最大的资源。

getPropagationBehavior()返回事务的传播行为，由是否有一个活动的事务来决定一个事务调用。

在TransactionDefinition接口中定义了七个事务传播行为。

PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA{

3.……

4.methodB();

5.……

6.}

7.

8.//事务属性 PROPAGATION_REQUIRED

9.methodB{

10.……

11.}

使用spring声明式事务，spring使用AOP来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

单独调用methodB方法

Java代码

1.main{

2. metodB();

3.}

相当于

Java代码

1.Main{

2.Connection con=null;

3.

4. rry{

5. con = getConnection();

6. con.setAutoCommit(false);

7.//方法调用

8.methodB();

9.//提交事务

https://www.360docs.net/doc/812877340.html,mit();

11.}

12.Catch(RuntimeException ex){

13. //回滚事务

14. con.rollback();

15.}

16.finally{

17. //释放资源

18. closeCon();

19.}

20.}

Spring保证在methodB方法中所有的调用都获得到一个相同的连接。在调用methodB时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。

单独调用MethodA时，在MethodA内又会调用MethodB.

执行效果相当于

Java代码

1.main{

2. Connection con = null;

3. try{

4. con = getConnection();

5. methodA();

6. https://www.360docs.net/doc/812877340.html,mit();

7.}

8.cathc(RuntimeException ex){

9. con.rollback();

10.}

11.finally{

12. closeCon();

13.}

14.}

调用MethodA时，环境中没有事务，所以开启一个新的事务.

当在MethodA中调用MethodB时，环境中已经有了一个事务，所以methodB就加入当前事务。

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

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. methodB();

4.}

5.

6.//事务属性 PROPAGATION_SUPPORTS

7.methodB(){

8.……

9.}

单纯的调用methodB时，methodB方法是非事务的执行的。

当调用methdA时,methodB则加入了methodA的事务中,事务地执行。

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

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. methodB();

4.}

5.

6.//事务属性 PROPAGATION_MANDATORY

7.methodB(){

8.……

9.}

当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常

throw new IllegalTransactionStateException("Transaction propagation 'mandatory' but no existing transaction found");

当调用methodA时，methodB则加入到methodA的事务中，事务地执行。

PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. doSomeThingA();

4.methodB();

5.doSomeThingB();

6.}

7.

8.//事务属性 PROPAGATION_REQUIRES_NEW

9.methodB(){

10.……

11.}

当单独调用methodB时，相当于把methodb声明为REQUIRED。开启一个新的事务，事务地执行。

当调用methodA时

Java代码

1.main(){

2. methodA();

3.}

情况有些大不一样.相当于下面的效果。

Java代码

1.main(){

2. TransactionManager tm = null;

3.try{

4. //获得一个JTA事务管理器

5. tm = getTransactionManager();

6. tm.begin();//开启一个新的事务

7. Transaction ts1 = tm.getTransaction();

8. doSomeThing();

9. tm.suspend();//挂起当前事务

10. try{

11. tm.begin();//重新开启第二个事务

12. Transaction ts2 = tm.getTransaction();

13. methodB();

14. https://www.360docs.net/doc/812877340.html,mit();//提交第二个事务

15.

16. }

17. Catch(RunTimeException ex){

18. ts2.rollback();//回滚第二个事务

19. }

20. finally{

21. //释放资源

22. }

23. //methodB执行完后，复恢第一个事务

24. tm.resume(ts1);

25.doSomeThingB();

26. https://www.360docs.net/doc/812877340.html,mit();//提交第一个事务

27.}

28.catch(RunTimeException ex){

29. ts1.rollback();//回滚第一个事务

30.}

31.finally{

32. //释放资源

33.}

34.}

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

使用PROPAGATION_REQUIRES_NEW,需要使用JtaTransactionManager作为事务管理器。PROPAGATION_NOT_SUPPORTED总是非事务地执行，并挂起任何存在的事务。

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. doSomeThingA();

4.methodB();

5.doSomeThingB();

6.}

7.

8.//事务属性 PROPAGATION_NOT_SUPPORTED

9.methodB(){

10.……

11.}

当单独调用methodB时，不启用任何事务机制，非事务地执行。

当调用methodA时，相当于下面的效果

Java代码

1.main(){

2. TransactionManager tm = null;

3.try{

4. //获得一个JTA事务管理器

5. tm = getTransactionManager();

6. tm.begin();//开启一个新的事务

7. Transaction ts1 = tm.getTransaction();

8. doSomeThing();

9. tm.suspend();//挂起当前事务

10. methodB();

11. //methodB执行完后，复恢第一个事务

12. tm.resume(ts1);

13.doSomeThingB();

14. https://www.360docs.net/doc/812877340.html,mit();//提交第一个事务

15.}

16.catch(RunTimeException ex){

17. ts1.rollback();//回滚第一个事务

18.}

19.finally{

20. //释放资源

21.}

22.}

使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。PROPAGATION_NEVER总是非事务地执行，如果存在一个活动事务，则抛出异常

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. doSomeThingA();

4.methodB();

5.doSomeThingB();

6.}

7.

8.//事务属性 PROPAGATION_NEVER

9.methodB(){

10.……

11.}

单独调用methodB，则非事务的执行。

调用methodA则会抛出异常

throw new IllegalTransactionStateException(

"Transaction propagation 'never' but existing transaction found");

PROPAGATION_NESTED如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。

使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;

而nestedTransactionAllowed属性值默认为false;

Java代码

1.//事务属性 PROPAGATION_REQUIRED

2.methodA(){

3. doSomeThingA();

4.methodB();

5.doSomeThingB();

6.}

7.

8.//事务属性 PROPAGATION_NESTED

9.methodB(){

10.……

11.}

如果单独调用methodB方法，则按REQUIRED属性执行。

如果调用methodA方法，相当于下面的效果

Java代码

1.main(){

2.Connection con = null;

3.Savepoint savepoint = null;

4.try{

5. con = getConnection();

6. con.setAutoCommit(false);

7. doSomeThingA();

8. savepoint = con2.setSavepoint();

9. try

10. methodB();

11. }catch(RuntimeException ex){

12. con.rollback(savepoint);

13. }

14. finally{

15. //释放资源

16. }

17.

18. doSomeThingB();

19. https://www.360docs.net/doc/812877340.html,mit();

20.}

21.catch(RuntimeException ex){

22. con.rollback();

23.}

24.finally{

25. //释放资源

26.}

27.}

当methodB方法调用之前，调用setSavepoint方法，保存当前的状态到savepoint。如果methodB方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括methodB方法的所有操作。

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

PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用

PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要JTA事务管理器的支持。

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

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