spring事物二（建基）

前言：暴走咯！！！！

• 　   PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
• 　　PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
• 　　PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
• 　　PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
• 　　PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
• 　   PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
• 　   PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

 

        PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行. 
    另一方面, PROPAGATION_NESTED 开始一个 "嵌套的" 事务,  它是已经存在事务的一个真正的子事务. 潜套事务开始执行时,  它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交. 

    由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会被 commit, 这个规则同样适用于 roll back.  

 

下面就让我们看些案例

一：a、b都会回滚,都是用同一个事物

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        b.inser();
        int c = 5/0;

    }
}

class b{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
    }
}

二：a、b都会回滚（b异常抛到a里）

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        b.inser();
    }
}


class b{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void insert(){
        sql insert();//这一行就当做db交互
        int c = 5/0;
    }
}

三：a会回滚、b不会 （b的事物和a不是一个，b已经执行完提交了）

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        b.inser();
        int c = 5/0;
    }
}


class b{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void insert(){
        sql insert();//这一行就当做db交互
    }
}

四：b会回滚、a不会。（异常包住了）

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        try {
            b.inser();
        }catch (Exception e){

        }
    }
}

class b{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void insert(){
        sql insert();//这一行就当做db交互
        int c = 5/0;
    }
}

五：a不会回滚、b会。（a都没有事物）

class a{
    void insert(){
        sql insert();//这一行就当做db交互
        b.inser();

    }
}


class b{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void insert(){
        sql insert();//这一行就当做db交互
        int c = 5/0;
    }
}

六：a、b都会回滚（）

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        b.inser();
        int c = 5/0;

    }
}


class b{
    @Transactional(propagation = Propagation.NESTED)
    void insert(){
        sql insert();//这一行就当做db交互
    }
}

六：a不会回滚、b会回滚（同样异常被包掉了）

class a{
    @Transactional(propagation = Propagation.REQUIRED)
    void insert(){
        sql insert();//这一行就当做db交互
        try {
            b.inser();
        }catch (Exception e){
            
        }
        int c = 5/0;

    }
}


class b{
    @Transactional(propagation = Propagation.NESTED)
    void insert(){
        sql insert();//这一行就当做db交互
    }
}

 

那就这样吧

 

哦，对了，下面这篇文章还不错

https://www.cnblogs.com/mcahkf/p/9228609.html