你了解Spring事務傳播行為嗎？多個方法之間呼叫事務如何傳播？-有解無憂

前言:

Spring在TransactionDefinition介面中規定了7種型別的事務傳播行為，事務傳播行為是Spring框架獨有的事務增強特性，他不屬于的事務實際提供方資料庫行為，這是Spring為我們提供的強大的工具箱，使用事務傳播行可以為我們的開發作業提供許多便利，但是人們對他的誤解也頗多，你一定也聽過“service方法事務最好不要嵌套”的傳言，要想正確的使用工具首先需要了解工具，本文對七種事務傳播行為做詳細介紹，內容主要代碼示例的方式呈現，

基礎概念:

1. 什么是事務傳播行為？

事務傳播行為用來描述由某一個事務傳播行為修飾的方法被嵌套進另一個方法的時事務如何傳播，

用偽代碼說明：

 public void methodA(){
    methodB();
    
 }
 
 @Transaction(Propagation=XXX)
 public void methodB(){
    
 }

代碼中methodA()方法嵌套呼叫了methodB()方法，methodB()的事務傳播行為由@Transaction(Propagation=XXX)設定決定，這里需要注意的是methodA()并沒有開啟事務，某一個事務傳播行為修飾的方法并不是必須要在開啟事務的外圍方法中呼叫，

2. Spring中七種事務傳播行為

定義非常簡單，也很好理解，下面我們就進入代碼測驗部分，驗證我們的理解是否正確，

代碼驗證:

文中代碼以傳統三層結構中兩層呈現，即Service和Dao層，由Spring負責依賴注入和注解式事務管理，DAO層由Mybatis實作，你也可以使用任何喜歡的方式，

例如，Hibernate,JPA,JDBCTemplate等，資料庫使用的是MySQL資料庫，你也可以使用任何支持事務的資料庫，并不會影響驗證結果，

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是通過開啟新的事務實作的，內部事務和外圍事務是兩個事務，外圍事務回滾不會影響內部事務，

結論

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

寫在最后

歡迎大家關注我的公眾號【風平浪靜如碼】，海量Java相關文章，學習資料都會在里面更新，整理的資料也會放在里面，

覺得寫的還不錯的就點個贊，加個關注唄！點關注，不迷路，持續更新！！！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/242676.html

標籤：Java

上一篇：設計模式-七大軟體設計原則

下一篇：開源編解碼專案FFmpeg迎來20周年生日憑一己之力養活全球無數播放器！