详解spring事务属性

 

先了解一下数据库并发操作带来的数据不一致性包括三类：丢失修改，不可重复读（第二个事务修改，或插入，或删除，应该说幻读是指插入或删除的情况），脏读。
 

T1	T2	T1	T2	T1	T2
①读A=16		①读A＝50 读B＝150 求和150		①读C=100 C＝C*2 写回C
②	读A=16	②	读B=100 B=B*2 写回B=200	②	读C=200
③A=A-1 写回A=15		③读A=50 读B＝200 求和250		③ROLLBACk C恢复到100
④	A=A-1 写回A=15
丢失修改		不可重复读		脏读

一般数据库原理的书中通过“锁”来解决这种并发操作带来的问题

基本的锁类型有两种：排它锁Exclusive Locks简称X锁和共享锁Share Locks，简称S锁

排它锁又称写锁，若事务T对数据对象A加上X锁，则只允许T读取和修改A，其他任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。这就保证了其他事务在T释放A上的锁之前不能再读取和修改A
共享锁又称读锁，若事务T对数据对象A加上S锁，则事务T可以读A但不能修改A，其他事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。这就保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何的修改。

一级封锁协议：事务T在修改数据R之前必须先对其加X锁，直到事务结束才释放，这里的事务结束包括正常结束COMMIT和非正常结束ROLLBACK
一级封锁协议可以防止丢失修改，并保证事务T是可恢复的
在一级锁协议中，如果仅仅是读数据不对其进行修改，是不需要加锁的，所以它不能保证可重复读和不读脏数据

二级封锁协议：一级锁协议加上事务T在读取数据R之前必须先对其加S锁，读完后即可释放S锁
二级封锁协议除了防止丢失修改，还可以进一步防止读“脏”数据
在二级锁协议中，由于读完数据后即可释放S锁，所以它不能保证可重复读

三级锁协议：一级封锁协议加上事务T在读取数据R之前必须对其加S锁，直到事务结束才释放S锁
三级封锁协议除防止了丢失修改和不读“脏”数据外，还进一步防止了不可重复读

Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。 
我们在使用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";   
3. con2.commit();  

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;   
3. con2.commit();  

在事务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);   
3. con2.commit();  

事务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. //提交事务   
10. con.commit();   
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.        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("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.       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();//开启一个新的事务   
7.     Transaction ts1 = tm.getTransaction();   
8.     doSomeThing();   
9.     tm.suspend();//挂起当前事务   
10.       methodB();   
11.    //methodB执行完后，复恢第一个事务   
12.     tm.resume(ts1);   
13. doSomeThingB();   
14.     ts1.commit();//提交第一个事务   
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.    con.commit();   
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应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。




数据库提供了四种事务隔离级别, 不同的隔离级别采用不同的锁类开来实现. 

在四种隔离级别中, Serializable的级别最高, Read Uncommited级别最低. 

大多数数据库的默认隔离级别为: Read Commited,如Sql Server , Oracle. 

少数数据库默认的隔离级别为Repeatable Read, 如MySQL InnoDB存储引擎 


Read Uncommited :读未提交数据( 会出现脏读,不可重复读,幻读) 

Read Commited :读已提交的数据(会出现不可重复读,幻读) 

Repeatable Read :可重复读(会出现幻读) 

Serializable :串行化 


丢失 更新 : 
当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，会发生丢失更新问题。每个事务都不知道其它事务的存在。最后的更新将重写由其它事务所做的更新，这将导致数据丢失。 　　 
例: 
事务A和事务B同时修改某行的值， 
1.事务A将数值改为1并提交 
2.事务B将数值改为2并提交。 
这时数据的值为2，事务A所做的更新将会丢失。 
解决办法：对行加锁，只允许并发一个更新事务。 



脏读: 一个事务读到另一个事务未提交的更新数据 

例: 


1.Mary的原工资为1000, 财务人员将Mary的工资改为了8000(但未提交事务) 
2.Mary读取自己的工资 ,发现自己的工资变为了8000，欢天喜地！ 
3.而财务发现操作有误，回滚了事务,Mary的工资又变为了1000, 像这样,Mary记取的工资数8000是一个脏数据。 



不可重复读: 在同一个事务中,多次读取同一数据,返回的结果有所不同. 换句话说就是,后续读取可以读到另一个事务已提交的更新数据. 相反"可重复读"在同一事务多次读取数据时,能够保证所读数据一样,也就是后续读取不能读到另一事务已提交的更新数据. 

例: 


1.在事务1中，Mary 读取了自己的工资为1000,操作并没有完成 
2.在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务. 
3.在事务1中，Mary 再次读取自己的工资时，工资变为了2000 
解决办法：如果只有在修改事务完全提交之后才可以读取数据，则可以避免该问题。 



幻读: 一个事务读取到另一个事务已提交的insert数据. 

例: 

第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时 (此时第一事务还未提交) ，第二个事务向表中插入一行新数据。这时第一个事务再去读取表时,发现表中还有没有修改的数据行，就好象发生了幻觉一样。



二、Isolation Level(事务隔离等级): 
1、Serializable：最严格的级别，事务串行执行，资源消耗最大； 
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。 
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。 
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。隔离级别在于处理多事务的并发问题。 
我们知道并行可以提高数据库的吞吐量和效率，但是并不是所有的并发事务都可以并发运行，这需要查看数据库教材的可串行化条件判断了。 
这里就不阐述。 
我们首先说并发中可能发生的3中不讨人喜欢的事情 
1： Dirty reads--读脏数据。也就是说，比如事务A的未提交（还依然缓存）的数据被事务B读走，如果事务A失败回滚，会导致事务B所读取的的数据是错误的。 
2： non-repeatable reads--数据不可重复读。比如事务A中两处读取数据-total-的值。在第一读的时候，total是100，然后事务B就把total的数据改成200，事务A再读一次，结果就发现，total竟然就变成200了，造成事务A数据混乱。 
3： phantom reads--幻象读数据，这个和non-repeatable reads相似，也是同一个事务中多次读不一致的问题。但是non-repeatable reads的不一致是因为他所要取的数据集被改变了（比如total的数据），但是phantom reads所要读的数据的不一致却不是他所要读的数据集改变，而是他的条件数据集改变。比如Select account.id where account.name="ppgogo*",第一次读去了6个符合条件的id，第二次读取的时候，由于事务b把一个帐号的名字由"dd"改成"ppgogo1"，结果取出来了7个数据。 Dirty reads non-repeatable reads phantom reads 
Serializable 不会 不会 不会 
REPEATABLE READ 不会 不会 会 
READ COMMITTED 不会 会 会 
Read Uncommitted 会 会 会 

三、readOnly 
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。 

四、Timeout 在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。