详解spring事务属性

Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。
我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。
Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是spring事务管理的核心接口。

TransactionDefinition
public interface TransactionDefinition {
    int getPropagationBehavior();
    int getIsolationLevel();
    int getTimeout();
    boolean isReadOnly();
}

getTimeout()方法，它返回事务必须在多少秒内完成。
isReadOnly(),事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。
getIsolationLevel()方法返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。

在TransactionDefinition接口中定义了五个不同的事务隔离级别
ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应
ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
  例如:
  Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务

  Connection con1 = getConnection();
  con.setAutoCommit(false);
  update employee set salary = 8000 where empId ="Mary";

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

Connection con2 = getConnection();
select  salary from employee where empId ="Mary";
con2.commit();

Mary发现自己的工资变为了8000，欢天喜地！
而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000

//con1
  con1.rollback();

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

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

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

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

con1 = getConnection();
select salary from employee empId ="Mary";

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

con2 = getConnection();
update employee set salary = 2000;
con2.commit();

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

//con1
select salary from employee empId ="Mary";

在一个事务中前后两次读取的结果并不致，导致了不可重复读。
使用ISOLATION_REPEATABLE_READ可以避免这种情况发生。

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

目前工资为1000的员工有10人。
事务1,读取所有工资为1000的员工。

con1 = getConnection();
Select * from employee where salary =1000;

共读取10条记录

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

con2 = getConnection();
Insert into employee(empId,salary) values("Lili",1000);
con2.commit();

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

//con1
select * from employee where salary =1000;

共读取到了11条记录，这就产生了幻像读。
ISOLATION_SERIALIZABLE能避免这样的情况发生。但是这样也耗费了最大的资源。

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

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

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

//事务属性 PROPAGATION_REQUIRED
methodA{
……
methodB();
……
}

//事务属性 PROPAGATION_REQUIRED
methodB{
   ……
}

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

单独调用methodB方法

main{
  metodB();
}

相当于

Main{
Connection con=null;

   rry{
      con = getConnection();
      con.setAutoCommit(false);
//方法调用
methodB();
//提交事务
con.commit();
}
Catch(RuntimeException ex){
  //回滚事务
  con.rollback();  
}
finally{
  //释放资源
  closeCon();
}
}

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

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

执行效果相当于

main{
   Connection con = null;
   try{
      con = getConnection();
      methodA();
      con.commit();
}
cathc(RuntimeException ex){
 con.rollback();
}
finally{
  closeCon();
} 
}

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

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

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  methodB();
}

//事务属性 PROPAGATION_SUPPORTS 
methodB(){
  ……
}

单纯的调用methodB时，methodB方法是非事务的执行的。
当调用methdA时,methodB则加入了methodA的事务中,事务地执行。

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

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  methodB();
}

//事务属性 PROPAGATION_MANDATORY 
methodB(){
  ……
}

当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常
throw new IllegalTransactionStateException("Transaction propagation 'mandatory' but no existing transaction found");

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

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

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_REQUIRES_NEW 
methodB(){
  ……
}

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

当调用methodA时

main(){
  methodA();
}

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

main(){
 TransactionManager tm = null;
try{
  //获得一个JTA事务管理器
   tm = getTransactionManager();
   tm.begin();//开启一个新的事务
   Transaction ts1 = tm.getTransaction();
   doSomeThing();
   tm.suspend();//挂起当前事务
   try{
     tm.begin();//重新开启第二个事务
     Transaction ts2 = tm.getTransaction();
     methodB();
     ts2.commit();//提交第二个事务
     
   }
  Catch(RunTimeException ex){
     ts2.rollback();//回滚第二个事务
  }
  finally{
    //释放资源
  }
   //methodB执行完后，复恢第一个事务
   tm.resume(ts1);
doSomeThingB();
   ts1.commit();//提交第一个事务
}
catch(RunTimeException ex){
  ts1.rollback();//回滚第一个事务
}
finally{
  //释放资源
}
}

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

PROPAGATION_NOT_SUPPORTED  总是非事务地执行，并挂起任何存在的事务。

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NOT_SUPPORTED 
methodB(){
  ……
}

当单独调用methodB时，不启用任何事务机制，非事务地执行。
当调用methodA时，相当于下面的效果

main(){
 TransactionManager tm = null;
try{
  //获得一个JTA事务管理器
   tm = getTransactionManager();
   tm.begin();//开启一个新的事务
   Transaction ts1 = tm.getTransaction();
   doSomeThing();
   tm.suspend();//挂起当前事务
     methodB();
   //methodB执行完后，复恢第一个事务
   tm.resume(ts1);
doSomeThingB();
   ts1.commit();//提交第一个事务
}
catch(RunTimeException ex){
  ts1.rollback();//回滚第一个事务
}
finally{
  //释放资源
}
}

使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NEVER 
methodB(){
  ……
}

单独调用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;

//事务属性 PROPAGATION_REQUIRED 
methodA(){
  doSomeThingA();
methodB();
doSomeThingB();
}

//事务属性 PROPAGATION_NESTED
methodB(){
  ……
}

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

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

main(){
Connection con = null;
Savepoint savepoint = null;
try{
  con = getConnection();
  con.setAutoCommit(false);
  doSomeThingA();
  savepoint = con2.setSavepoint();
  try
      methodB();
  }catch(RuntimeException ex){
     con.rollback(savepoint);
  }
  finally{
    //释放资源
  }

  doSomeThingB();
  con.commit();
}
catch(RuntimeException ex){
  con.rollback();
}
finally{
  //释放资源
}
}

当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应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

评论

38 楼 xly_971223 2007-05-23  

klyuan 写道

xly_971223 写道

ISOLATION_READ_COMMITTED是在这个事务提交前其他事务看不到数据的变化（别人看不到我的变化）
ISOLATION_REPEATABLE_READ是在同一个事务中保证了重复读取的数据是一致的，即不能读取其他事务提交的数据（我看不到别人变化）
ISOLATION_SERIALIZABLE是在同一个事务中保证重复读取的数据条数是一致的，感觉也是在这个事务没结束之前不能读取其他事务提交的数据（我看不到别人变化）
可以这样理解吗？

不是这个概念吧！！！

那还得去仔细理解一下

37 楼 klyuan 2007-05-23  

xly_971223 写道

ISOLATION_READ_COMMITTED是在这个事务提交前其他事务看不到数据的变化（别人看不到我的变化）
ISOLATION_REPEATABLE_READ是在同一个事务中保证了重复读取的数据是一致的，即不能读取其他事务提交的数据（我看不到别人变化）
ISOLATION_SERIALIZABLE是在同一个事务中保证重复读取的数据条数是一致的，感觉也是在这个事务没结束之前不能读取其他事务提交的数据（我看不到别人变化）
可以这样理解吗？

不是这个概念吧！！！

36 楼 xly_971223 2007-05-17  

ISOLATION_READ_COMMITTED是在这个事务提交前其他事务看不到数据的变化（别人看不到我的变化）
ISOLATION_REPEATABLE_READ是在同一个事务中保证了重复读取的数据是一致的，即不能读取其他事务提交的数据（我看不到别人变化）
ISOLATION_SERIALIZABLE是在同一个事务中保证重复读取的数据条数是一致的，感觉也是在这个事务没结束之前不能读取其他事务提交的数据（我看不到别人变化）
可以这样理解吗？

35 楼 whw200297132 2007-05-16  

有帮助。谢谢LZ

34 楼 eddie 2007-05-15  

moshalanye 写道

   谢谢楼主的简洁的解说，对自己帮助很大，我对spring的事物没有太深的认识，所以我想问下，在一般我们在使用AOP处理事物，使用的是最简单的异常捕捉的事物回滚的拦截器，因为复杂点的事物回滚都是需要更多的信息的，就象前面要回滚到哪里，那么那些标志flag信息也会在莫个地方存取的吧？ 能介绍下吗？  呵呵

这个问题我来回答下，spring的声明式事务和j2ee的完全一样。
即：
默认情况下，发生运行时异常事，事务将被回滚；发生受查异常（checked exception）时，不回滚。
即，如果你自己在服务层抛出受查异常（checked exception）时，别指望Spring会帮你回滚事务。
如果希望，可以这么声明：

		<property name="transactionAttributes">
			<props>
				<prop key="save*">PROPAGATION_REQUIRED</prop>
				<prop key="insert*">PROPAGATION_REQUIRED</prop>
				<prop key="remove*">PROPAGATION_REQUIRED</prop>
				<prop key="init*">PROPAGATION_REQUIRED</prop>
				<prop key="disconnect*">
					PROPAGATION_REQUIRED,
					-DataSourceDisconnectException
				</prop>
				<prop key="connect*">
					PROPAGATION_REQUIRED, -DataSourceConnectException
				</prop>
				<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
			</props>
		</property>

其中-DataSourceDisconnectException，表示发生这个异常时，将回滚事务。反之，+开始的异常定义发生这样的异常也不回滚（好像不怎么常用）。

33 楼 superbo8888 2007-05-15  

非常精彩的Spring事务分析！已收藏

32 楼 cskysnew 2007-05-15  

非常好的文章，对初学者很有帮助，谢谢搂主

31 楼 shaucle 2007-05-14  

"jdbc with "save points" supports suspend and resume"
这个好像没什么依据
如：suspend后如果rollback，并不应该rollback到savepoint，而应该是最前面的那个。

关于suspend，我看了下源码，对于DataSourceTransactionManager,只是做了unbindResource from a ThreadLocal，而spring封装的transaction只操作(如commit/rollback)其bind的Resource,也就是说系统的操作不会影响到被这个unbind的Transaction。
而resume则执行重新bind操作，这样当前Transaction又加入到当前系统可操作(如commit/rollback)的Resouce列队中。

其它TransactionManager也有些类似。

30 楼 shaucle 2007-05-14  

"aop的实现主要有两种方法，字节码生成和代理！"

aop有三种:
1 编译时
2 loading时
3 runtime

spring aop 是runtime的(基于cglib/jdkProxy的动态字节码生成)
aspectJ支持前两种.(要进行weaver编译)

因此daquan198163所说的embeded那个问题是存在的.

29 楼 klyuan 2007-05-14  

moshalanye 写道

   谢谢楼主的简洁的解说，对自己帮助很大，我对spring的事物没有太深的认识，所以我想问下，在一般我们在使用AOP处理事物，使用的是最简单的异常捕捉的事物回滚的拦截器，因为复杂点的事物回滚都是需要更多的信息的，就象前面要回滚到哪里，那么那些标志flag信息也会在莫个地方存取的吧？ 能介绍下吗？  呵呵

声明式事务现在是以方法抛出的异常信息来决定提交或回滚的！！！

我不太明白你说什么，可否详细说明！！！

28 楼 moshalanye 2007-05-14  

   谢谢楼主的简洁的解说，对自己帮助很大，我对spring的事物没有太深的认识，所以我想问下，在一般我们在使用AOP处理事物，使用的是最简单的异常捕捉的事物回滚的拦截器，因为复杂点的事物回滚都是需要更多的信息的，就象前面要回滚到哪里，那么那些标志flag信息也会在莫个地方存取的吧？ 能介绍下吗？  呵呵

27 楼 daquan198163 2007-05-14  

klyuan 写道

daquan198163 写道

klyuan 写道

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

你确定么？
切点和切面在哪里也要先拦截到才能发挥作用阿
这就好比：即便你为一个bean配置了事务，但如果别人直接去调用这个类的实现而不是你配置的那个AOP代理，那么这个调用就完全不是事务的了！

目前，aop的实现主要有两种方法，字节码生成和代理！
如果使用字节码生成，绝不会出现这种情况！！！
如果使用代理，则会出现这样情况！！在spring1.0中，spring aop是用代理来实现的！！！
spring 2.0可以支持原生的aspectJ。
没有研究过spring2.0的aop

有接口的用代理，没有接口的用字节码生成
但是结果是一样的，因为这个字节码生成是运行时产生的，并不修改目标类的字节码
因此，对目标类方法的直接调用还是可以绕过AOP的拦截

26 楼 klyuan 2007-05-14  

daquan198163 写道

klyuan 写道

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

你确定么？
切点和切面在哪里也要先拦截到才能发挥作用阿
这就好比：即便你为一个bean配置了事务，但如果别人直接去调用这个类的实现而不是你配置的那个AOP代理，那么这个调用就完全不是事务的了！

目前，aop的实现主要有两种方法，字节码生成和代理！
如果使用字节码生成，绝不会出现这种情况！！！
如果使用代理，则会出现这样情况！！在spring1.0中，spring aop是用代理来实现的！！！
spring 2.0可以支持原生的aspectJ。
没有研究过spring2.0的aop

25 楼 klyuan 2007-05-14  

eddie 写道

daquan198163 写道

klyuan 写道

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

你确定么？
切点和切面在哪里也要先拦截到才能发挥作用阿
这就好比：即便你为一个bean配置了事务，但如果别人直接去调用这个类的实现而不是你配置的那个AOP代理，那么这个调用就完全不是事务的了！

daquan198163说的是对的，同一个类里面2个方法的互相调用，第2个方法的事务声明方式不会起任何作用。
因为声明式事务都是通过事务代理类-即AOP层来实现的，类里面的直接调用是没有通过AOP代理类的，它也不能可进行拦截，所以被调用的方法的事务声明不会生效。

如果是单纯的方法调用，的确是不会产生拦截的！！！
不过倒底是不是这样还需要证实！！

24 楼 eddie 2007-05-14  

daquan198163 写道

klyuan 写道

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

你确定么？
切点和切面在哪里也要先拦截到才能发挥作用阿
这就好比：即便你为一个bean配置了事务，但如果别人直接去调用这个类的实现而不是你配置的那个AOP代理，那么这个调用就完全不是事务的了！

daquan198163说的是对的，同一个类里面2个方法的互相调用，第2个方法的事务声明方式不会起任何作用。
因为声明式事务都是通过事务代理类-即AOP层来实现的，类里面的直接调用是没有通过AOP代理类的，它也不能可进行拦截，所以被调用的方法的事务声明不会生效。

23 楼 daquan198163 2007-05-14  

klyuan 写道

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

你确定么？
切点和切面在哪里也要先拦截到才能发挥作用阿
这就好比：即便你为一个bean配置了事务，但如果别人直接去调用这个类的实现而不是你配置的那个AOP代理，那么这个调用就完全不是事务的了！

22 楼 Qieqie 2007-05-14  

klyuan 写道

Qieqie 写道

klyuan 写道

jdbc的Connection只有简单的commit 和rollbacke

只有jta事务管理器才有suspend和resume!

not the case!

jdbc with "save points" supports suspend and resume

晕！！！当然你可以通过保存点来实现事务挂起和恢复！！！
前题是必须是同一个connection!!!!

当一个是数据库事务，而另外一个不是事务库事务时，怎么办？

并且，spring对require_new的处理，并没有有像NESTED那样使用JDBC 的save point!!!!

我是看错你帖子文字了 在你回帖的之前 已删除

不过你的表述太快了，有漏洞：
save point 在同一连接中， 并不能去产生新的事务 所以不支持required_new
即：“不可以保存点来实现事务挂起和恢复 哪怕是同一个connection”

你果然被我弄晕了


PS:
你感叹号太多了

21 楼 klyuan 2007-05-14  

daquan198163 写道

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

这个要看你的声明方式，与是否在同一个类中没有任何关系！！！

只是看你的切点和切面在哪里！！！

20 楼 daquan198163 2007-05-14  

当然是支持的了
methodA是在内部对methodB直接调用，他们在同一个类中，调用不能被aop拦截到

19 楼 klyuan 2007-05-14  

daquan198163 写道

klyuan 写道

spiritfrog 写道

好文章！但是为什么使用PROPAGATION_REQUIRES_NEW,就一定要使用JtaTransactionManager作为事务管理器呢？

因为需要把前一个事务挂起！！！
目前只有jta事务管理器才能实现把事务挂起和恢复事务！！！

可以另取一个连接啊

required_new,当存在一个当前事务时，是会去新取得一个连接的！！！！