Spring事務傳播行為：

spring特有的事務傳播行為，spring支援7種事務傳播行為，確定客戶端和被呼叫端的事務邊界（說得通俗一點就是多個具有事務控制的service的相互呼叫時所形成的複雜的事務邊界控制）下圖所示為7鍾事務傳播機制

o

Spring配置宣告式事務：

* 配置DataSource
* 配置事務管理器
* 事務的傳播特性
* 那些類那些方法使用事務

Spring配置檔案中關於事務配置總是由三個組成部分，分別是DataSource、TransactionManager和代理機制這三部分，無論哪種配置方式，一般變化的只是代理機制這部分。

DataSource、TransactionManager這兩部分只是會根據資料訪問方式有所變化，比如使用Hibernate進行資料訪問 時，DataSource實際為SessionFactory，TransactionManager的實現為 HibernateTransactionManager。

根據代理機制的不同，Spring事務的配置又有幾種不同的方式：

第一種方式：每個Bean都有一個代理

第二種方式：所有Bean共享一個代理基類

第三種方式：使用攔截器

第四種方式：使用tx標籤配置的攔截器

第五種方式：全註解

注意點：

1、Spring的事務邊界是在呼叫業務方法之前開始的，業務方法執行完畢之後來執行commit 或者rollback，取決於是否丟擲runtime異常。

1.PROPAGATION_REQUIRED

我們為User1Service和User2Service相應方法加上Propagation.REQUIRED屬性。

User1Service方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}複製程式碼

User2Service方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User2 user){
        user2Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequiredException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
    
}複製程式碼

1.1 場景一

此場景外圍方法沒有開啟事務。

驗證方法1：

    @Override
    public void notransaction_exception_required_required(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequired(user2);
        
        throw new RuntimeException();
    }複製程式碼

驗證方法2：

    @Override
    public void notransaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }複製程式碼

分別執行驗證方法，結果：

結論：通過這兩個方法我們證明了在外圍方法未開啟事務的情況下Propagation.REQUIRED修飾的內部方法會新開啟自己的事務，且開啟的事務相互獨立，互不干擾。

1.2 場景二

外圍方法開啟事務，這個是使用率比較高的場景。

驗證方法1：

   @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_required(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequired(user2);
        
        throw new RuntimeException();
    }複製程式碼

驗證方法2：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }複製程式碼

驗證方法3：

    @Transactional
    @Override
    public void transaction_required_required_exception_try(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        try {
            user2Service.addRequiredException(user2);
        } catch (Exception e) {
            System.out.println("方法回滾");
        }
    }複製程式碼

分別執行驗證方法，結果：

結論：以上試驗結果我們證明在外圍方法開啟事務的情況下Propagation.REQUIRED修飾的內部方法會加入到外圍方法的事務中，所有Propagation.REQUIRED修飾的內部方法和外圍方法均屬於同一事務，只要一個方法回滾，整個事務均回滾。

2.PROPAGATION_REQUIRES_NEW

我們為User1Service和User2Service相應方法加上Propagation.REQUIRES_NEW屬性。
User1Service方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User1 user){
        user1Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}複製程式碼

User2Service方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User2 user){
        user2Mapper.insert(user);
    }
    
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNewException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}複製程式碼

2.1 場景一

外圍方法沒有開啟事務。

驗證方法1：

    @Override
    public void notransaction_exception_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequiresNew(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        throw new RuntimeException();
        
    }複製程式碼

驗證方法2：

    @Override
    public void notransaction_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequiresNew(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNewException(user2);
    }複製程式碼

分別執行驗證方法，結果：

結論：通過這兩個方法我們證明了在外圍方法未開啟事務的情況下Propagation.REQUIRES_NEW修飾的內部方法會新開啟自己的事務，且開啟的事務相互獨立，互不干擾。

2.2 場景二

外圍方法開啟事務。

驗證方法1：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        
        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNew(user3);
        throw new RuntimeException();
    }複製程式碼

驗證方法2：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        
        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNewException(user3);
    }複製程式碼

驗證方法3：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_requiresNew_requiresNew_exception_try(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        User2 user3=new User2();
        user3.setName("王五");
        try {
            user2Service.addRequiresNewException(user3);
        } catch (Exception e) {
            System.out.println("回滾");
        }
    }複製程式碼

分別執行驗證方法，結果：

結論：在外圍方法開啟事務的情況下Propagation.REQUIRES_NEW修飾的內部方法依然會單獨開啟獨立事務，且與外部方法事務也獨立，內部方法之間、內部方法和外部方法事務均相互獨立，互不干擾。

3.PROPAGATION_NESTED

我們為User1Service和User2Service相應方法加上Propagation.NESTED屬性。
User1Service方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User1 user){
        user1Mapper.insert(user);
    }
}複製程式碼

User2Service方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User2 user){
        user2Mapper.insert(user);
    }
    
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNestedException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}複製程式碼

3.1 場景一

此場景外圍方法沒有開啟事務。

驗證方法1：

    @Override
    public void notransaction_exception_nested_nested(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addNested(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNested(user2);
        throw new RuntimeException();
    }複製程式碼

驗證方法2：

    @Override
    public void notransaction_nested_nested_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addNested(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNestedException(user2);
    }複製程式碼

分別執行驗證方法，結果：

結論：通過這兩個方法我們證明了在外圍方法未開啟事務的情況下Propagation.NESTED和Propagation.REQUIRED作用相同，修飾的內部方法都會新開啟自己的事務，且開啟的事務相互獨立，互不干擾。

3.2 場景二

外圍方法開啟事務。

驗證方法1：

    @Transactional
    @Override
    public void transaction_exception_nested_nested(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addNested(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNested(user2);
        throw new RuntimeException();
    }複製程式碼

驗證方法2：

    @Transactional
    @Override
    public void transaction_nested_nested_exception(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addNested(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNestedException(user2);
    }複製程式碼

驗證方法3：

    @Transactional
    @Override
    public void transaction_nested_nested_exception_try(){
        User1 user1=new User1();
        user1.setName("張三");
        user1Service.addNested(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        try {
            user2Service.addNestedException(user2);
        } catch (Exception e) {
            System.out.println("方法回滾");
        }
    }複製程式碼

分別執行驗證方法，結果：

結論：以上試驗結果我們證明在外圍方法開啟事務的情況下Propagation.NESTED修飾的內部方法屬於外部事務的子事務，外圍主事務回滾，子事務一定回滾，而內部子事務可以單獨回滾而不影響外圍主事務和其他子事務

4. REQUIRED,REQUIRES_NEW,NESTED異同

由“1.2 場景二”和“3.2 場景二”對比，我們可知：
NESTED和REQUIRED修飾的內部方法都屬於外圍方法事務，如果外圍方法丟擲異常，這兩種方法的事務都會被回滾。但是REQUIRED是加入外圍方法事務，所以和外圍事務同屬於一個事務，一旦REQUIRED事務丟擲異常被回滾，外圍方法事務也將被回滾。而NESTED是外圍方法的子事務，有單獨的儲存點，所以NESTED方法丟擲異常被回滾，不會影響到外圍方法的事務。

由“2.2 場景二”和“3.2 場景二”對比，我們可知：
NESTED和REQUIRES_NEW都可以做到內部方法事務回滾而不影響外圍方法事務。但是因為NESTED是巢狀事務，所以外圍方法回滾之後，作為外圍方法事務的子事務也會被回滾。而REQUIRES_NEW是通過開啟新的事務實現的，內部事務和外圍事務是兩個事務，外圍事務回滾不會影響內部事務。

5. 其他事務傳播行為

鑑於文章篇幅問題，其他事務傳播行為的測試就不在此一一描述了，感興趣的讀者可以去原始碼中自己尋找相應測試程式碼和結果解釋。傳送門：github.com/TmTse/tran…

模擬用例

介紹了這麼多事務傳播行為，我們在實際工作中如何應用呢？下面我來舉一個示例：

假設我們有一個註冊的方法，方法中呼叫新增積分的方法，如果我們希望新增積分不會影響註冊流程（即新增積分執行失敗回滾不能使註冊方法也回滾），我們會這樣寫：

   @Service
   public class UserServiceImpl implements UserService {
        
        @Transactional
        public void register(User user){
                   
            try {
                membershipPointService.addPoint(Point point);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }
        //省略...
   }複製程式碼

我們還規定註冊失敗要影響addPoint()方法（註冊方法回滾新增積分方法也需要回滾），那麼addPoint()方法就需要這樣實現：

   @Service
   public class MembershipPointServiceImpl implements MembershipPointService{
        
        @Transactional(propagation = Propagation.NESTED)
        public void addPoint(Point point){
                   
            try {
                recordService.addRecord(Record record);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }
        //省略...
   }複製程式碼

我們注意到了在addPoint()中還呼叫了addRecord()方法，這個方法用來記錄日誌。他的實現如下：

   @Service
   public class RecordServiceImpl implements RecordService{
        
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void addRecord(Record record){
                   
           
            //省略...
        }
        //省略...
   }複製程式碼

我們注意到addRecord()方法中propagation = Propagation.NOT_SUPPORTED，因為對於日誌無所謂精確，可以多一條也可以少一條，所以addRecord()方法本身和外圍addPoint()方法丟擲異常都不會使addRecord()方法回滾，並且addRecord()方法丟擲異常也不會影響外圍addPoint()方法的執行。

通過這個例子相信大家對事務傳播行為的使用有了更加直觀的認識，通過各種屬性的組合確實能讓我們的業務實現更加靈活多樣。

結論

通過上面的介紹，相信大家對Spring事務傳播行為有了更加深入的理解，希望大家日常開發工作有所幫助。