Spring对于事物的管理

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. con.commit(); 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(\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. ts2.commit();//提交第二个事务 15. 16. }

17. Catch(RunTimeException ex){

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

20. finally{ 21. //释放资源 22. }

23. //methodB执行完后，复恢第一个事务 24. tm.resume(ts1); 25. doSomeThingB();

26. ts1.commit();//提交第一个事务

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();//开启一个新的事务