Spring-@Transactional的事务隔离级别

最新推荐文章于 2025-09-09 17:27:59 发布

原创最新推荐文章于 2025-09-09 17:27:59 发布 · 4.4k 阅读

7 ·

CC 4.0 BY-SA版权

Spring 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Spring中@Transactional注解的事务隔离级别，包括PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS等，并通过案例分析了不同隔离级别在事务处理中的行为差异，特别是PROPAGATION_REQUIRED和PROPAGATION_NESTED的区别。当事务嵌套时，如何影响事务的回滚及提交策略。

//支持当前事务，如果当前没有事务，就新建一个事务。Spring默认事务级别。

int PROPAGATION_REQUIRED = 0;

//支持当前事务，如果当前没有事务，就以非事务方式执行。

int PROPAGATION_SUPPORTS = 1;

//支持当前事务，如果当前没有事务，就抛出异常。

int PROPAGATION_MANDATORY = 2;

//新建事务，如果当前存在事务，把当前事务挂起。执行新事务后，再激活当前事务。

int PROPAGATION_REQUIRES_NEW = 3;

//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

int PROPAGATION_NOT_SUPPORTED = 4;

//以非事务方式执行，如果当前存在事务，则抛出异常。

int PROPAGATION_NEVER = 5;

//如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

//嵌套时由外部事务决定，子事务是否是commit还是rollback。

//一般在外部事务是使用try{}catch(嵌套事务方法){}进行编码。

int PROPAGATION_NESTED = 6;

案例分析1：

@Service
class A{
    @Autowired
    B b;

    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            //doSomething....
            //不抛异常，则A无法提交
        }
        //doSomething....
    }
}

@Service
class B{
    @Transactional(propagation = Propagation.REQUIRED)
    void call(){}
}

A和B共用事务，如果B异常。A未使用try..catch..捕获，则AB一起回滚。

如果B异常。A捕获，但并未抛出。则A最终也无法提交，因为B的事务已经被设置为rollback-only了。

案例分析2：

@Service
class A{
    @Autowired
    B b;

    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            throw e; //或者不抛
        }
        //doSomething....
    }
}

@Service
class B{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void call(){}
}

执行b.call()时A事务挂起，此时如果B执行异常。被A捕获，如果抛出异常，则AB回滚；如果A捕获未抛异常，则A继续执行不回滚。

执行b.call()时A事务挂起，此时如果B正常执行，而在A中出现异常。则B不回滚，A回滚。

案例分析3：

@Service
class A{
    @Autowired
    B b;

    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            throw e; //或者不抛
        }
        //doSomething....
    }
}

@Service
class B{
    @Transactional(propagation = Propagation.NESTED)
    void call(){}
}

执行b.call()时A事务挂起，B新起事务并设置SavePoint。如果B正常执行，A出现异常，则AB一起回滚。

如果B失败异常，此时A如果捕获但未抛出，后续A正常执行的话，A可以提交，而B已经回滚。

如果B失败异常，此时A如果捕获且抛出，则AB一起回滚。

以上案例，我们可以得出第1种和第3种模式的区别，第3种在嵌套模式下，可以在内部异常下执行其它业务且外部正常提交，而第1种不可以这么操作。