Spring事务传播，Spring中七种事务传播行为

Spring中七种事务传播行为：

1. REQUIRED：

使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；

如果当前存在事务，则加入这个事务，成为一个整体

• 举例：领导有饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。

2. SUPPORTS：

如果当前有事务，则使用事务；如果当前没有事务，则不适用事务

• 举例：领导没饭吃，我也没饭吃；领导有饭吃，我也有饭吃。

3. MANDATORY：

该传播属性强制必须存在一个事务，如果不存在，则抛出异常

• 举例：领导必须管饭，不管饭没饭吃，我就不干了（抛出异常）

4. REQUIRES_NEW：

如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；

如果当前没有事务，则同REQUIRED

• 举例：领导有饭吃，我偏不要，我自己买了自己吃

5. NOT_SUPPORTED：

如果当前有事务，则把事务挂起，自己不使用事务去运行数据库操作

• 举例：领导有饭吃，分一点给你，我太忙了，放一边，我不吃

6. NEVER：

如果当前有事务存在，则抛出异常

• 举例：领导有饭给你吃，我不想吃，我热爱工作，我抛出异常

7. NESTED：

如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；

如果当前没有事务，则同REQUIRED。

但是如果主事务提交，则会携带子事务一起提交。

如果主事务回滚，则子事务会一起回滚。

相反，子事务异常，则父事务可以回滚或不回滚

• 举例： 领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任或一起承担责任

源码中的注释

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.transaction.annotation;

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.
     * <p>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.
     * <p>Note: For transaction managers with transaction synchronization,
     * {@code 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, and suspend the current transaction if one exists.
     * Analogous to the EJB transaction attribute of the same name.
     * <p><b>NOTE:</b> 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 javax.transaction.TransactionManager} to be
     * made available to it (which is server-specific in standard Java EE).
     * @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.
     * <p><b>NOTE:</b> 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 javax.transaction.TransactionManager} to be
     * made available to it (which is server-specific in standard Java EE).
     * @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 {@code REQUIRED} otherwise. There is no analogous feature in EJB.
     * <p>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. 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;
    }

}