Spring事务传播级别理解

• REQUIRED: 默认事务传播级别，如果当前没有事务，就新建一个事务，如果当前存在事务，就加入这个事务

  • 内外为同一个事务，外部回滚内部也回滚，内部回滚外部也回滚

  • public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void testB(){
        B(b1);  //调用B入参b1
        throw Exception;     //发生异常抛出
        B(b2);  //调用B入参b2
    }
    

    上面a1会存入，b1b2会回滚，因为testB没有事务就新建一个事务

• SUPPORTS:当前存在事务则加入当前事务，如果当前没有事务，就以非事务方法执行

  • public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
    }
    @Transactional(propagation = Propagation.SUPPORTS)
    public void testB(){
        B(b1);  //调用B入参b1
        throw Exception;     //发生异常抛出
        B(b2);  //调用B入参b2
    }
    

    这种情况下a1、b1、会存入,b2不会存，因为调用方testmain没有开启事务，testb是SUPPORTS，即以非事务方法执行

• MANDATORY:当前存在事务则加入当前事务，如果当前没有事务，就抛出异常

  • public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
    }
    @Transactional(propagation = Propagation.MANDATORY)
    public void testB(){
        B(b1);  //调用B入参b1
        throw Exception;     //发生异常抛出
        B(b2);  //调用B入参b2
    }
    

    a1会存储，b1b2不会存储，之所以b1没有存储的是因为MANDATORY只要是非事务就会抛出异常，还没走到b1就报错了，如果testmain设置了required的话就会以事务方式运行，可以正常回滚

• REQUIRES_NEW: 创建一个新事务，如果当前存在事务，则挂起该事务

  • @Transactional(propagation = Propagation.REQUIRED)
    public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
        throw Exception;     //发生异常抛出
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void testB(){
        B(b1);  //调用B入参b1
        B(b2);  //调用B入参b2
    }
    

    上面a1会回滚，b1b2不会回滚，因为开启了新的事务，即外部回滚内部不回滚，内部回滚外部不回滚

• NOT_SUPPORTED:始终以非事务方式执行，如果当前存在事务，则挂起当前事务

  • @Transactional(propagation = Propagation.REQUIRED)
    public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
    }
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void testB(){
        B(b1);  //调用B入参b1
        throw Exception;     //发生异常抛出
        B(b2);  //调用B入参b2
    }
    

    a1b2不会存储，b1会存储，因为testb没有事务，当b1执行完后抛出异常会导致testmain回滚，导致a1也不会存储

• NEVER:不使用事务，如果当前事务存在则抛出异常

  • @Transactional(propagation = Propagation.REQUIRED)
    public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
    }
    @Transactional(propagation = Propagation.NEVER)
    public void testB(){
        B(b1);  //调用B入参b1
        B(b2);  //调用B入参b2
    }
    

    上面a1b1b2都不会存储，因为testb会抛出异常导致testmain回滚

• NESTED:如果当前存在事务，则在嵌套事务中执行，否则和REQUIRED的操作一样（开启一个事务）

  • @Transactional(propagation = Propagation.REQUIRED)
    public void testMain(){
        A(a1);  //调用A入参a1
        testB();    //调用testB
        throw Exception;     //发生异常抛出
    }
    @Transactional(propagation = Propagation.NESTED)
    public void testB(){
        B(b1);  //调用B入参b1
        B(b2);  //调用B入参b2
    }
    

    上面都不会存储，因为testb子事务会跟着testmain父事务的回滚而回滚

  • @Transactional(propagation = Propagation.REQUIRED)
    public void testMain(){
        A(a1);  //调用A入参a1
        try{
            testB();    //调用testB
        }catch（Exception e){
    
        }
        A(a2);
    }
    @Transactional(propagation = Propagation.NESTED)
    public void testB(){
        B(b1);  //调用B入参b1
        throw Exception;     //发生异常抛出
        B(b2);  //调用B入参b2
    }
    

    a1a2会存储，b1b2会回滚，因为父事务catch了异常所以只有子事务回滚了，如果这里的testb传播级别是REQUIRED的话都不会存储，因为是在同一个事务中