Spring聲明式事務讓我們從復雜的事務處理中得到解脫。使得我們再也無需要去處理獲得連接、關(guān)閉連接、事務提交和回滾等這些操作。再也無需要我們在與事務相關(guān)的方法中處理大量的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. }  

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

getTimeout()方法，它返回事務必須在多少秒內(nèi)完成。
isReadOnly(),事務是否只讀，事務管理器能夠根據(jù)這個返回值進行優(yōu)化，確保事務是只讀的。
getIsolationLevel()方法返回事務的隔離級別，事務管理器根據(jù)它來控制另外一個事務可以看到本事務內(nèi)的哪些數(shù)據(jù)。

在TransactionDefinition接口中定義了五個不同的事務隔離級別
ISOLATION_DEFAULT 這是一個PlatfromTransactionManager默認的隔離級別，使用數(shù)據(jù)庫默認的事務隔離級別.另外四個與JDBC的隔離級別相對應
ISOLATION_READ_UNCOMMITTED 這是事務最低的隔離級別，它充許別外一個事務可以看到這個事務未提交的數(shù)據(jù)。這種隔離級別會產(chǎn)生臟讀，不可重復讀和幻像讀。
  例如:
  Mary的原工資為1000,財務人員將Mary的工資改為了8000，但未提交事務

Java代碼

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

  Connection con1 = getConnection();
con.setAutoCommit(false);
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();  

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

Mary發(fā)現(xiàn)自己的工資變?yōu)榱?000，歡天喜地！
而財務發(fā)現(xiàn)操作有誤，而回滾了事務,Mary的工資又變?yōu)榱?000

Java代碼

1. //con1   
2.   con1.rollback();  

//con1
con1.rollback();

像這樣,Mary記取的工資數(shù)8000是一個臟數(shù)據(jù)。

ISOLATION_READ_COMMITTED  保證一個事務修改的數(shù)據(jù)提交后才能被另外一個事務讀取。另外一個事務不能讀取該事務未提交的數(shù)據(jù)。這種事務隔離級別可以避免臟讀出現(xiàn)，但是可能會出現(xiàn)不可重復讀和幻像讀。

ISOLATION_REPEATABLE_READ  這種事務隔離級別可以防止臟讀，不可重復讀。但是可能出現(xiàn)幻像讀。它除了保證一個事務不能讀取另一個事務未提交的數(shù)據(jù)外，還保證了避免下面的情況產(chǎn)生(不可重復讀)。

在事務1中，Mary 讀取了自己的工資為1000,操作并沒有完成

Java代碼

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

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

在事務2中，這時財務人員修改了Mary的工資為2000,并提交了事務.

Java代碼

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

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

在事務1中，Mary 再次讀取自己的工資時，工資變?yōu)榱?000

Java代碼

1. //con1   
2. select salary from employee empId ="Mary";  

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

在一個事務中前后兩次讀取的結(jié)果并不致，導致了不可重復讀。
使用ISOLATION_REPEATABLE_READ可以避免這種情況發(fā)生。

ISOLATION_SERIALIZABLE 這是花費最高代價但是最可靠的事務隔離級別。事務被處理為順序執(zhí)行。除了防止臟讀，不可重復讀外，還避免了幻像讀。

目前工資為1000的員工有10人。
事務1,讀取所有工資為1000的員工。

Java代碼

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

con1 = getConnection();
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();  

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

事務1再次讀取所有工資為1000的員工

Java代碼

1. //con1   
2. select * from employee where salary =1000;  

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

共讀取到了11條記錄，這就產(chǎn)生了幻像讀。
ISOLATION_SERIALIZABLE能避免這樣的情況發(fā)生。但是這樣也耗費了最大的資源。

getPropagationBehavior()返回事務的傳播行為，由是否有一個活動的事務來決定一個事務調(diào)用。

在TransactionDefinition接口中定義了七個事務傳播行為。

PROPAGATION_REQUIRED 如果存在一個事務，則支持當前事務。如果沒有事務則開啟一個新的事務。

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED   
2. methodA{   
3. ……   
4. methodB();   
5. ……   
6. }   
7.   
8. //事務屬性 PROPAGATION_REQUIRED   
9. methodB{   
10.    ……   
11. }  

//事務屬性 PROPAGATION_REQUIRED
methodA{
……
methodB();
……
}
//事務屬性 PROPAGATION_REQUIRED
methodB{
……
}

使用spring聲明式事務，spring使用AOP來支持聲明式事務，會根據(jù)事務屬性，自動在方法調(diào)用之前決定是否開啟一個事務，并在方法執(zhí)行之后決定事務提交或回滾事務。

單獨調(diào)用methodB方法

Java代碼

1. main{   
2.   metodB();   
3. }  

main{
metodB();
}

相當于

Java代碼

1. Main{   
2. Connection con=null;   
3.   
4.    rry{   
5.       con = getConnection();   
6.       con.setAutoCommit(false);   
7. //方法調(diào)用   
8. methodB();   
9. //提交事務   
10. con.commit();   
11. }   
12. Catch(RuntimeException ex){   
13.   //回滾事務   
14.   con.rollback();     
15. }   
16. finally{   
17.   //釋放資源   
18.   closeCon();   
19. }   
20. }  

Main{
Connection con=null;
rry{
con = getConnection();
con.setAutoCommit(false);
//方法調(diào)用
methodB();
//提交事務
con.commit();
}
Catch(RuntimeException ex){
//回滾事務
con.rollback();
}
finally{
//釋放資源
closeCon();
}
}

Spring保證在methodB方法中所有的調(diào)用都獲得到一個相同的連接。在調(diào)用methodB時，沒有一個存在的事務，所以獲得一個新的連接，開啟了一個新的事務。

單獨調(diào)用MethodA時，在MethodA內(nèi)又會調(diào)用MethodB.

執(zhí)行效果相當于

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. }  

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

調(diào)用MethodA時，環(huán)境中沒有事務，所以開啟一個新的事務.
當在MethodA中調(diào)用MethodB時，環(huán)境中已經(jīng)有了一個事務，所以methodB就加入當前事務。

PROPAGATION_SUPPORTS 如果存在一個事務，支持當前事務。如果沒有事務，則非事務的執(zhí)行。但是對于事務同步的事務管理器，PROPAGATION_SUPPORTS與不使用事務有少許不同。

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   methodB();   
4. }   
5.   
6. //事務屬性 PROPAGATION_SUPPORTS    
7. methodB(){   
8.   ……   
9. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
methodB();
}
//事務屬性 PROPAGATION_SUPPORTS
methodB(){
……
}

單純的調(diào)用methodB時，methodB方法是非事務的執(zhí)行的。
當調(diào)用methdA時,methodB則加入了methodA的事務中,事務地執(zhí)行。

PROPAGATION_MANDATORY 如果已經(jīng)存在一個事務，支持當前事務。如果沒有一個活動的事務，則拋出異常。

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   methodB();   
4. }   
5.   
6. //事務屬性 PROPAGATION_MANDATORY    
7. methodB(){   
8.   ……   
9. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
methodB();
}
//事務屬性 PROPAGATION_MANDATORY
methodB(){
……
}

當單獨調(diào)用methodB時，因為當前沒有一個活動的事務，則會拋出異常
throw new IllegalTransactionStateException("Transaction propagation 'mandatory' but no existing transaction found");

當調(diào)用methodA時，methodB則加入到methodA的事務中，事務地執(zhí)行。

PROPAGATION_REQUIRES_NEW 總是開啟一個新的事務。如果一個事務已經(jīng)存在，則將這個存在的事務掛起。

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   doSomeThingA();   
4. methodB();   
5. doSomeThingB();   
6. }   
7.   
8. //事務屬性 PROPAGATION_REQUIRES_NEW    
9. methodB(){   
10.   ……   
11. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
doSomeThingA();
methodB();
doSomeThingB();
}
//事務屬性 PROPAGATION_REQUIRES_NEW
methodB(){
……
}

當單獨調(diào)用methodB時，相當于把methodb聲明為REQUIRED。開啟一個新的事務，事務地執(zhí)行。

當調(diào)用methodA時

Java代碼

1. main(){   
2.   methodA();   
3. }  

main(){
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.    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執(zhí)行完后，復恢第一個事務   
24.    tm.resume(ts1);   
25. doSomeThingB();   
26.    ts1.commit();//提交第一個事務   
27. }   
28. catch(RunTimeException ex){   
29.   ts1.rollback();//回滾第一個事務   
30. }   
31. finally{   
32.   //釋放資源   
33. }   
34. }  

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執(zhí)行完后，復恢第一個事務
tm.resume(ts1);
doSomeThingB();
ts1.commit();//提交第一個事務
}
catch(RunTimeException ex){
ts1.rollback();//回滾第一個事務
}
finally{
//釋放資源
}
}

在這里，我把ts1稱為外層事務，ts2稱為內(nèi)層事務。從上面的代碼可以看出，ts2與ts1是兩個獨立的事務，互不相干。Ts2是否成功并不依賴于ts1。如果methodA方法在調(diào)用methodB方法后的doSomeThingB方法失敗了，而methodB方法所做的結(jié)果依然被提交。而除了methodB之外的其它代碼導致的結(jié)果卻被回滾了。
使用PROPAGATION_REQUIRES_NEW,需要使用JtaTransactionManager作為事務管理器。

PROPAGATION_NOT_SUPPORTED  總是非事務地執(zhí)行，并掛起任何存在的事務。

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   doSomeThingA();   
4. methodB();   
5. doSomeThingB();   
6. }   
7.   
8. //事務屬性 PROPAGATION_NOT_SUPPORTED    
9. methodB(){   
10.   ……   
11. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
doSomeThingA();
methodB();
doSomeThingB();
}
//事務屬性 PROPAGATION_NOT_SUPPORTED
methodB(){
……
}

當單獨調(diào)用methodB時，不啟用任何事務機制，非事務地執(zhí)行。
當調(diào)用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執(zhí)行完后，復恢第一個事務   
12.    tm.resume(ts1);   
13. doSomeThingB();   
14.    ts1.commit();//提交第一個事務   
15. }   
16. catch(RunTimeException ex){   
17.   ts1.rollback();//回滾第一個事務   
18. }   
19. finally{   
20.   //釋放資源   
21. }   
22. }  

main(){
TransactionManager tm = null;
try{
//獲得一個JTA事務管理器
tm = getTransactionManager();
tm.begin();//開啟一個新的事務
Transaction ts1 = tm.getTransaction();
doSomeThing();
tm.suspend();//掛起當前事務
methodB();
//methodB執(zhí)行完后，復恢第一個事務
tm.resume(ts1);
doSomeThingB();
ts1.commit();//提交第一個事務
}
catch(RunTimeException ex){
ts1.rollback();//回滾第一個事務
}
finally{
//釋放資源
}
}

使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作為事務管理器。

PROPAGATION_NEVER 總是非事務地執(zhí)行，如果存在一個活動事務，則拋出異常

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   doSomeThingA();   
4. methodB();   
5. doSomeThingB();   
6. }   
7.   
8. //事務屬性 PROPAGATION_NEVER    
9. methodB(){   
10.   ……   
11. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
doSomeThingA();
methodB();
doSomeThingB();
}
//事務屬性 PROPAGATION_NEVER
methodB(){
……
}

單獨調(diào)用methodB，則非事務的執(zhí)行。
調(diào)用methodA則會拋出異常
throw new IllegalTransactionStateException(
"Transaction propagation 'never' but existing transaction found");


PROPAGATION_NESTED如果一個活動的事務存在，則運行在一個嵌套的事務中. 如果沒有活動事務, 則按TransactionDefinition.PROPAGATION_REQUIRED 屬性執(zhí)行

這是一個嵌套事務,使用JDBC 3.0驅(qū)動時,僅僅支持DataSourceTransactionManager作為事務管理器。需要JDBC 驅(qū)動的java.sql.Savepoint類。有一些JTA的事務管理器實現(xiàn)可能也提供了同樣的功能。

使用PROPAGATION_NESTED，還需要把PlatformTransactionManager的nestedTransactionAllowed屬性設(shè)為true;
而nestedTransactionAllowed屬性值默認為false;

Java代碼

1. //事務屬性 PROPAGATION_REQUIRED    
2. methodA(){   
3.   doSomeThingA();   
4. methodB();   
5. doSomeThingB();   
6. }   
7.   
8. //事務屬性 PROPAGATION_NESTED   
9. methodB(){   
10.   ……   
11. }  

//事務屬性 PROPAGATION_REQUIRED
methodA(){
doSomeThingA();
methodB();
doSomeThingB();
}
//事務屬性 PROPAGATION_NESTED
methodB(){
……
}

如果單獨調(diào)用methodB方法，則按REQUIRED屬性執(zhí)行。

如果調(diào)用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. }  

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方法調(diào)用之前，調(diào)用setSavepoint方法，保存當前的狀態(tài)到savepoint。如果methodB方法調(diào)用失敗，則恢復到之前保存的狀態(tài)。但是需要注意的是，這時的事務并沒有進行提交，如果后續(xù)的代碼(doSomeThingB()方法)調(diào)用失敗，則回滾包括methodB方法的所有操作。

嵌套事務一個非常重要的概念就是內(nèi)層事務依賴于外層事務。外層事務失敗時，會回滾內(nèi)層事務所做的動作。而內(nèi)層事務操作失敗并不會引起外層事務的回滾。

PROPAGATION_NESTED 與PROPAGATION_REQUIRES_NEW的區(qū)別:它們非常類似,都像一個嵌套事務，如果不存在一個活動的事務，都會開啟一個新的事務。使用PROPAGATION_REQUIRES_NEW時，內(nèi)層事務與外層事務就像兩個獨立的事務一樣，一旦內(nèi)層事務進行了提交后，外層事務不能對其進行回滾。兩個事務互不影響。兩個事務不是一個真正的嵌套事務。同時它需要JTA事務管理器的支持。
使用PROPAGATION_NESTED時，外層事務的回滾可以引起內(nèi)層事務的回滾。而內(nèi)層事務的異常并不會導致外層事務的回滾，它是一個真正的嵌套事務。DataSourceTransactionManager使用savepoint支持PROPAGATION_NESTED時，需要JDBC 3.0以上驅(qū)動及1.4以上的JDK版本支持。其它的JTA TrasactionManager實現(xiàn)可能有不同的支持方式。

PROPAGATION_REQUIRED應該是我們首先的事務傳播行為。它能夠滿足我們大多數(shù)的事務需求。