spring 事务传播机制总结

spring事务的传播机制定义在 TransactionDefinition 接口中，定义了如下传播类型

PROPAGATION_REQUIRED

支持当前事务，如果没有当前事务就创建一个新的事务，是默认的传播行为。

外围方法未开启事务

内部会创建新事务，若新事务回滚，不影响外围方法。

外围方法开启事务

内部方法会加入到外围方法的事务中，使用同一个事务，不管内外谁发生异常，整个事务都将回滚。

/ * Support a current transaction; create a new one if none exists. * Analogous to the EJB transaction attribute of the same name. * 
This is typically the default setting of a transaction definition, * and typically defines a transaction synchronization scope. */ int PROPAGATION_REQUIRED = 0;

PROPAGATION_SUPPORTS

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

外围方法未开启事务

以非事务方法运行。

外围方法开启事务

内部方法会加入到外围方法的事务中，使用同一个事务，不管内外谁发生异常，整个事务都将回滚。

 / * Support a current transaction; execute non-transactionally if none exists. * Analogous to the EJB transaction attribute of the same name. * 
NOTE: For transaction managers with transaction synchronization, * {@code PROPAGATION_SUPPORTS} is slightly different from no transaction * at all, as it defines a transaction scope that synchronization might apply to. * As a consequence, the same resources (a JDBC {@code Connection}, a * Hibernate {@code Session}, etc) will be shared for the entire specified * scope. Note that the exact behavior depends on the actual synchronization * configuration of the transaction manager! * 
In general, use {@code PROPAGATION_SUPPORTS} with care! In particular, do * not rely on {@code PROPAGATION_REQUIRED} or {@code PROPAGATION_REQUIRES_NEW} * within a {@code PROPAGATION_SUPPORTS} scope (which may lead to * synchronization conflicts at runtime). If such nesting is unavoidable, make sure * to configure your transaction manager appropriately (typically switching to * "synchronization on actual transaction"). * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#SYNCHRONIZATION_ON_ACTUAL_TRANSACTION */ int PROPAGATION_SUPPORTS = 1;

PROPAGATION_MANDATORY

mandatory是强制的意思，支持当前事务，如果没有事务，就抛出一个异常

外围方法未开启事务

抛出一个异常。

外围方法开启事务

内部方法会加入到外围方法的事务中，使用同一个事务，不管内外谁发生异常，整个事务都将回滚。

 / * Support a current transaction; throw an exception if no current transaction * exists. Analogous to the EJB transaction attribute of the same name. * 
Note that transaction synchronization within a {@code PROPAGATION_MANDATORY} * scope will always be driven by the surrounding transaction. */ int PROPAGATION_MANDATORY = 2;

PROPAGATION_REQUIRES_NEW

不管当前是否存在事务，都创建一个新事务，如果存在事务，将当前事务暂停(挂起)

外围方法未开启事务

内部会创建新事务，若内部事务回滚，不影响外围方法。

外围方法开启事务

内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。

代码验证REQUIRES_NEW事务传播机制

代码验证REQUIRES_NEW事务传播机制https://blog.csdn.net/leisure_life/article/details/124478838

 / * Create a new transaction, suspending the current transaction if one exists. * Analogous to the EJB transaction attribute of the same name. * 
NOTE: Actual transaction suspension will not work out-of-the-box * on all transaction managers. This in particular applies to * {@link org.springframework.transaction.jta.JtaTransactionManager}, * which requires the {@code jakarta.transaction.TransactionManager} to be * made available it to it (which is server-specific in standard Jakarta EE). * 
A {@code PROPAGATION_REQUIRES_NEW} scope always defines its own * transaction synchronizations. Existing synchronizations will be suspended * and resumed appropriately. * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager */ int PROPAGATION_REQUIRES_NEW = 3;

PROPAGATION_NOT_SUPPORTED

不支持事务，不管当前是否存在事务都以非事务方式执行。

外围方法未开启事务

以非事务方式执行。

外围方法开启事务

以非事务方式执行。

 / * Do not support a current transaction; rather always execute non-transactionally. * Analogous to the EJB transaction attribute of the same name. * 
NOTE: Actual transaction suspension will not work out-of-the-box * on all transaction managers. This in particular applies to * {@link org.springframework.transaction.jta.JtaTransactionManager}, * which requires the {@code jakarta.transaction.TransactionManager} to be * made available it to it (which is server-specific in standard Jakarta EE). * 
Note that transaction synchronization is not available within a * {@code PROPAGATION_NOT_SUPPORTED} scope. Existing synchronizations * will be suspended and resumed appropriately. * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager */ int PROPAGATION_NOT_SUPPORTED = 4;

PROPAGATION_NEVER

不支持事务，如果存在事务，会抛出一个异常

外围方法未开启事务

以非事务方式执行。

外围方法开启事务

抛出一个异常。

 / * Do not support a current transaction; throw an exception if a current transaction * exists. Analogous to the EJB transaction attribute of the same name. * 
Note that transaction synchronization is not available within a * {@code PROPAGATION_NEVER} scope. */ int PROPAGATION_NEVER = 5;

PROPAGATION_NESTED

如果存在当前事务，则在嵌套事务中执行，如果不存在事务，则和PROPAGATION_REQUIRED一样，会新建一个事务。

外围方法未开启事务

与Propagation.REQUIRED 作用相同，内部会创建新事务，若内部事务回滚，不影响外围方法。

外围方法开启事务

修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务。

 / * Execute within a nested transaction if a current transaction exists, * behave like {@link #PROPAGATION_REQUIRED} otherwise. There is no * analogous feature in EJB. * 
NOTE: Actual creation of a nested transaction will only work on * specific transaction managers. Out of the box, this only applies to the JDBC * {@link org.springframework.jdbc.datasource.DataSourceTransactionManager} * when working on a JDBC 3.0 driver. Some JTA providers might support * nested transactions as well. * @see org.springframework.jdbc.datasource.DataSourceTransactionManager */ int PROPAGATION_NESTED = 6;

总结

required，有就加入，没有就自己动手

required_new，不求人，自己动手，丰衣足食，互不干扰

supports，有就加入，没有也无所谓。

not_supports，有我也不用。

never，必须没有，有了就抛异常。

mandatory 与 never是一对反义词，mandatory 是必须共用一个事物，否则就抛异常；而never必须无事务，有事务就抛异常。

nested，有就嵌套，没有就玩自己的，外部影响内部，内部不影响外部。

​