31 05 2021

概述

事务的传播特性指的是不同方法的嵌套调用过程中,事务应该如何进行处理,是用同一个事务还是不同的事务,当出现异常的时候会回滚还是提交,两个方法之间的相关影响,在日常工作中,使用比较多的是REQUIRED、REQUIRES_NEW、NESTED。

Spring的事务传播机制有7种,在枚举Propagation中有定义。

  1. public enum Propagation {
  2. REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
  3. SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
  4. MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
  5. REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
  6. NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
  7. NEVER(TransactionDefinition.PROPAGATION_NEVER),
  8. NESTED(TransactionDefinition.PROPAGATION_NESTED);
  9. ...
  10. }

TransactionDefinition

  1. public interface TransactionDefinition {
  2. int PROPAGATION_REQUIRED = 0;
  3. int PROPAGATION_SUPPORTS = 1;
  4. int PROPAGATION_MANDATORY = 2;
  5. int PROPAGATION_REQUIRES_NEW = 3;
  6. int PROPAGATION_NOT_SUPPORTED = 4;
  7. int PROPAGATION_NEVER = 5;
  8. int PROPAGATION_NESTED = 6;
  9. ...
  10. }

REQUIRED

PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的默认设置。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. methodB();
  4. // do something
  5. }
  6. @Transactional(propagation = Propagation.REQUIRED)
  7. public void methodB(){
  8. // do something
  9. }

调用methdoA,如果methodB发生异常,触发事务回滚,也会methodA中的也会回滚。

SUPPORTS

PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就以非事务执行。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. methodB();
  4. // do something
  5. }
  6. @Transactional(propagation = Propagation.SUPPORTS)
  7. public void methodB(){
  8. // do something
  9. }

如果调用methodA,再调用methodB,MehtodB会加入到MethodA的开启的当前事务中。

如果直接调用methodB,当前没有事务,就以非事务执行。

MANDATORY

PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. methodB();
  4. // do something
  5. }
  6. @Transactional(propagation = Propagation.MANDATORY)
  7. public void methodB(){
  8. // do something
  9. }

如果调用methodA,再调用methodB,MehtodB会加入到MethodA的开启的当前事务中。

如果直接调用methodB,当前没有事务,就会抛出异常。

REQUIRES_NEW

PROPAGATION_REQUIRES_NEW:创建新事务,无论当前存不存在事务,都创建新事务。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. // do something pre
  4. methodB();
  5. // do something post
  6. }
  7. @Transactional(propagation = Propagation.REQUIRES_NEW)
  8. public void methodB(){
  9. // do something
  10. }

调用methodA,会先开启事务1,执行A的something pre的代码。再调用methodB,methdoB会开启一个事务2,再执行自身的代码。最后在执行methodA的something post。

如果method发生异常回滚,只是methodB中的代码回滚,不影响methodA中的代码。如果methodA发生异常回滚,只回滚methodA中的代码,不影响methodB中的代码。

NOT_SUPPORTED

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

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. methodB();
  4. // do something
  5. }
  6. @Transactional(propagation = Propagation.NOT_SUPPORTED)
  7. public void methodB(){
  8. // do something
  9. }

调用methodA,再调用methodB,methodA开启的事务会被挂起,即在methodB中不齐作用,相当于没有事务,methodB内部抛出异常不会回滚。methodA内的代码发生异常会回滚。

直接调用methodB,不会开启事务。

NEVER

PROPAGATION_NEVER:以非事务方式执行操作,如果当前存在事务,则抛出异常。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. methodB();
  4. // do something
  5. }
  6. @Transactional(propagation = Propagation.NEVER)
  7. public void methodB(){
  8. // do something
  9. }

NESTED

PROPAGATION_NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则按REQUIRED属性执行。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA(){
  3. // do something pre
  4. methodB();
  5. // do something post
  6. }
  7. @Transactional(propagation = Propagation.NESTED)
  8. public void methodB(){
  9. // do something
  10. }

调用methodA,开启一个事务,执行something pre的代码,设置回滚点savepoint,再调用methodB的代码,如果methodB里抛出异常,此时回滚到之前的saveponint。再然后执行methodA里的something post的代码,最后提交或者回滚事务。

嵌套事务,外层的事务如果回滚,会导致内层的事务也回滚;但是内层的事务如果回滚,仅仅是回滚自己的代码,不影响外层的事务的代码。

延伸阅读
  1. Spring(一): 初识
  2. Spring(二):初识 IOC
  3. Spring的事务传播机制
发表评论