Spring事務傳播行爲

時間  2019-11-15
標籤 spring 事務 傳播 行爲 欄目 Spring 简体版
原文   原文鏈接

Spring事務傳播行爲：

spring特有的事務傳播行爲，spring支持7種事務傳播行爲，肯定客戶端和被調用端的事務邊界（說得通俗一點就是多個具備事務控制的service的相互調用時所造成的複雜的事務邊界控制）下圖所示爲7鍾事務傳播機制git

ogithub

傳播行爲spring

含義數據庫

PROPAGATION_REQUIRED（XML文件中爲REQUIRED)bash

表示當前方法必須在一個具備事務的上下文中運行，若有客戶端有事務在進行，那麼被調用端將在該事務中運行，不然的話從新開啓一個事務。（若是被調用端發生異常，那麼調用端和被調用端事務都將回滾）app

PROPAGATION_SUPPORTS(XML文件中爲SUPPORTS）ide

表示當前方法沒必要須要具備一個事務上下文，可是若是有一個事務的話，它也能夠在這個事務中運行post

PROPAGATION_MANDATORY(XML文件中爲MANDATORY）測試

表示當前方法必須在一個事務中運行，若是沒有事務，將拋出異常ui

PROPAGATION_NESTED(XML文件中爲NESTED)

表示若是當前方法正有一個事務在運行中，則該方法應該運行在一個嵌套事務中，被嵌套的事務能夠獨立於被封裝的事務中進行提交或者回滾。若是封裝事務存在，而且外層事務拋出異常回滾，那麼內層事務必須回滾，反之，內層事務並不影響外層事務。若是封裝事務不存在，則同PROPAGATION_REQUIRED的同樣

PROPAGATION_NEVER（XML文件中爲NEVER)

表示當方法務不該該在一個事務中運行，若是存在一個事務，則拋出異常

PROPAGATION_REQUIRES_NEW(XML文件中爲REQUIRES_NEW）

表示當前方法必須運行在它本身的事務中。一個新的事務將啓動，並且若是有一個現有的事務在運行的話，則這個方法將在運行期被掛起，直到新的事務提交或者回滾才恢復執行。

PROPAGATION_NOT_SUPPORTED（XML文件中爲NOT_SUPPORTED）

表示該方法不該該在一個事務中運行。若是有一個事務正在運行，他將在運行期被掛起，直到這個事務提交或者回滾才恢復執行

Spring配置聲明式事務：

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

Spring配置文件中關於事務配置老是由三個組成部分，分別是DataSource、TransactionManager和代理機制這三部分，不管哪一種配置方式，通常變化的只是代理機制這部分。

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

wKioL1imzDzBn7knAAGOogF9_Uk501.jpg

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

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

第二種方式：全部Bean共享一個代理基類

第三種方式：使用攔截器

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

第五種方式：全註解

注意點：

一、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);
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」、「李四」均插入。 外圍方法未開啓事務，插入「張三」、「李四」方法在本身的事務中獨立運行，外圍方法異常不影響內部插入「張三」、「李四」方法獨立的事務。
2 「張三」插入，「李四」未插入。 外圍方法沒有事務，插入「張三」、「李四」方法都在本身的事務中獨立運行,因此插入「李四」方法拋出異常只會回滾插入「李四」方法，插入「張三」方法不受影響。

結論：經過這兩個方法咱們證實了在外圍方法未開啓事務的狀況下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("方法回滾");
        }
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」、「李四」均未插入。 外圍方法開啓事務，內部方法加入外圍方法事務，外圍方法回滾，內部方法也要回滾。
2 「張三」、「李四」均未插入。 外圍方法開啓事務，內部方法加入外圍方法事務，內部方法拋出異常回滾，外圍方法感知異常導致總體事務回滾。
3 「張三」、「李四」均未插入。 外圍方法開啓事務，內部方法加入外圍方法事務，內部方法拋出異常回滾，即便方法被catch不被外圍方法感知，整個事務依然回滾。

結論：以上試驗結果咱們證實在外圍方法開啓事務的狀況下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);
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」插入，「李四」插入。 外圍方法沒有事務，插入「張三」、「李四」方法都在本身的事務中獨立運行,外圍方法拋出異常回滾不會影響內部方法。
2 「張三」插入，「李四」未插入 外圍方法沒有開啓事務，插入「張三」方法和插入「李四」方法分別開啓本身的事務，插入「李四」方法拋出異常回滾，其餘事務不受影響。

結論：經過這兩個方法咱們證實了在外圍方法未開啓事務的狀況下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("回滾");
        }
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」未插入，「李四」插入，「王五」插入。 外圍方法開啓事務，插入「張三」方法和外圍方法一個事務，插入「李四」方法、插入「王五」方法分別在獨立的新建事務中，外圍方法拋出異常只回滾和外圍方法同一事務的方法，故插入「張三」的方法回滾。
2 「張三」未插入，「李四」插入，「王五」未插入。 外圍方法開啓事務，插入「張三」方法和外圍方法一個事務，插入「李四」方法、插入「王五」方法分別在獨立的新建事務中。插入「王五」方法拋出異常，首先插入 「王五」方法的事務被回滾，異常繼續拋出被外圍方法感知，外圍方法事務亦被回滾，故插入「張三」方法也被回滾。
3 「張三」插入，「李四」插入，「王五」未插入。 外圍方法開啓事務，插入「張三」方法和外圍方法一個事務，插入「李四」方法、插入「王五」方法分別在獨立的新建事務中。插入「王五」方法拋出異常，首先插入「王五」方法的事務被回滾，異常被catch不會被外圍方法感知，外圍方法事務不回滾，故插入「張三」方法插入成功。

結論：在外圍方法開啓事務的狀況下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);
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」、「李四」均插入。 外圍方法未開啓事務，插入「張三」、「李四」方法在本身的事務中獨立運行，外圍方法異常不影響內部插入「張三」、「李四」方法獨立的事務。
2 「張三」插入，「李四」未插入。 外圍方法沒有事務，插入「張三」、「李四」方法都在本身的事務中獨立運行,因此插入「李四」方法拋出異常只會回滾插入「李四」方法，插入「張三」方法不受影響。

結論：經過這兩個方法咱們證實了在外圍方法未開啓事務的狀況下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("方法回滾");
        }
    }複製代碼

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

驗證方法序號 數據庫結果 結果分析
1 「張三」、「李四」均未插入。 外圍方法開啓事務，內部事務爲外圍事務的子事務，外圍方法回滾，內部方法也要回滾。
2 「張三」、「李四」均未插入。 外圍方法開啓事務，內部事務爲外圍事務的子事務，內部方法拋出異常回滾，且外圍方法感知異常導致總體事務回滾。
3 「張三」插入、「李四」未插入。 外圍方法開啓事務，內部事務爲外圍事務的子事務，插入「張三」內部方法拋出異常，能夠單獨對子事務回滾。

結論：以上試驗結果咱們證實在外圍方法開啓事務的狀況下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事務傳播行爲有了更加深刻的理解，但願你們平常開發工做有所幫助。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程