import org.springframework.transaction.TransactionDefinition;/** * Enumeration that represents transaction propagation behaviors for use * with the {
     @link Transactional} annotation, corresponding to the * {
     @link TransactionDefinition} interface. * * @author Colin Sampaleanu * @author Juergen Hoeller * @since 1.2 */public enum Propagation {    /**     * Support a current transaction, create a new one if none exists.     * Analogous to EJB transaction attribute of the same name.     * 
This is the default setting of a transaction annotation.     */    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),    /**     * Support a current transaction, execute non-transactionally if none exists.     * Analogous to EJB transaction attribute of the same name.     * 
Note: For transaction managers with transaction synchronization,     * PROPAGATION_SUPPORTS is slightly different from no transaction at all,     * as it defines a transaction scope that synchronization will apply for.     * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)     * will be shared for the entire specified scope. Note that this depends on     * the actual synchronization configuration of the transaction manager.     * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization     */    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),    /**     * Support a current transaction, throw an exception if none exists.     * Analogous to EJB transaction attribute of the same name.     */    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),    /**     * Create a new transaction, suspend the current transaction if one exists.     * Analogous to EJB transaction attribute of the same name.     * 
Note: Actual transaction suspension will not work on out-of-the-box     * on all transaction managers. This in particular applies to JtaTransactionManager,     * which requires the {
     @code javax.transaction.TransactionManager} to be     * made available it to it (which is server-specific in standard J2EE).     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager     */    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),    /**     * Execute non-transactionally, suspend the current transaction if one exists.     * Analogous to EJB transaction attribute of the same name.     * 
Note: Actual transaction suspension will not work on out-of-the-box     * on all transaction managers. This in particular applies to JtaTransactionManager,     * which requires the {
     @code javax.transaction.TransactionManager} to be     * made available it to it (which is server-specific in standard J2EE).     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager     */    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),    /**     * Execute non-transactionally, throw an exception if a transaction exists.     * Analogous to EJB transaction attribute of the same name.     */    NEVER(TransactionDefinition.PROPAGATION_NEVER),    /**     * Execute within a nested transaction if a current transaction exists,     * behave like PROPAGATION_REQUIRED else. 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     * DataSourceTransactionManager when working on a JDBC 3.0 driver.     * Some JTA providers might support nested transactions as well.     * @see org.springframework.jdbc.datasource.DataSourceTransactionManager     */    NESTED(TransactionDefinition.PROPAGATION_NESTED);    private final int value;    Propagation(int value) { this.value = value; }    public int value() { return this.value; }}

 spring事务传播机制总共有7种！

当我们调用一个Service接口的方法时，它有可能在方法的内部调用其他的service接口方法以共同完成一个完整的业务操作，因此就会产生服务接口方法嵌套调用的情况，Spring通过事务传播行为控制当前事务如何传播到被嵌套调用的目标服务接口方法中。

Spring定义了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播。

事务传播行为类型	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务， 如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。 如果当前没有事务，则执行与PROPAGATION_REQUIRED类 似的操作。