Spring-@Transactional的事务隔离级别

//支持当前事务，如果当前没有事务，就新建一个事务。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种不可以这么操作。