spring 事务传播机制

yedongfeng_1314

于 2019-12-10 14:48:17 发布

阅读量113

点赞数

本文链接：https://blog.csdn.net/yedongfeng_1314/article/details/103472605

版权

浅谈一下对spring事务传播机制的理解：

1.spring事务大家都知道，本质上就是数据库的事务操作；如果方法没有开启事务，sql语句执行一条提交一条；如果有事务，sql语句一起成功，或失败回滚。sql语句执行后并不会立马提交，而是等方法内的sql都执行了再提交事务。

2.spring事务的传播机制：

/*
 * Copyright 2002-2015 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
 *
 *      http://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.
	 * B方法是REQUIRED,A方法调用B方法，假如A方法有事务(比如A方法也是REQUIRED)，
     * 则B方法加入A的 
     * 事务，若A方法没有事务，则B方法开启一个新事务；
	 * <p>This is the default setting of a transaction annotation.
	 */
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

	/**
	 * Support a current transaction, execute non-transactionally if none exists.
	 * B方法是SUPPORTS,A方法调用B方法，假如A方法有事务(比如A方法是REQUIRED)，则B方法加入A的 
     * 事务，若A方法没有事务(比如A方法是NOT_SUPPORTED)，则B方法也没事务； 
	 */
	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

	/**
	 * Support a current transaction, throw an exception if none exists.
	 * 方法必须在一个已有的事务中执行；即 必须是有事务的方法来调用
     * B方法是MANDATORY,A方法调用B方法，假如A方法有事务(比如A方法是REQUIRED)，则B方法加入A的 
     * 事务，若A方法没有事务(比如A方法是NOT_SUPPORTED)，则B抛出异常：注意a不会回滚，因为a没有开 
     * 启事务；
	 */
	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

	/**
	 * Create a new transaction, and suspend the current transaction if one exists.
	 * 开启新事务，挂起已存在的（即调用本方法的方法事务）
     * B方法是REQUIRES_NEW,A方法调用B方法，假如A方法有事务(比如A方法是REQUIRED)，A方法事务挂 
     * 起，B方法开启新事务，提交后继续执行A事务；若A方法没有事务(比如A方法是NOT_SUPPORTED)，B 
     * 方法开启新事务执行提交；所以A方法抛出异常不会回滚B方法的执行
     * 启事务
	 */
	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

	/**
	 * Execute non-transactionally, suspend the current transaction if one exists.
	 * 不支持事务
     * B方法是NOT_SUPPORTED,A方法调用B方法，假如A方法有事务(比如A方法是REQUIRED)，A方法事务挂 
     * 起，B方法执行，之后继续执行A事务；若A方法没有事务(比如A方法是NOT_SUPPORTED)，B 
     * 方法当然也还是没有事务的
	 */
	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

	/**
	 * Execute non-transactionally, throw an exception if a transaction exists.
	 * B方法是NEVER.任何有事务的方法调用B方法都会抛出异常 即 必须是没事务的方法来调用
	 */
	NEVER(TransactionDefinition.PROPAGATION_NEVER),

	/**
	 * Execute within a nested transaction if a current transaction exists,
	 * B方法是NESTED,A方法调用B方法，假如A方法有事务(比如A方法是REQUIRED)，B方法开启事务，嵌套 
     * 进A事务，本质上是一个事务；若A方法没有事务(比如A方法是NOT_SUPPORTED)，B 
     * 方法开启新事务执行提交；
     * 启事务 
	 */
	NESTED(TransactionDefinition.PROPAGATION_NESTED);


	private final int value;


	Propagation(int value) { this.value = value; }

	public int value() { return this.value; }

}

2.下面咱们按照对事务的支持与否排个序

1.SUPPORTS,支持事务功能，可有可无，看调用一方是否有事务，你有我就用，你没有我也不要求；
2.REQUIRED，事务默认传播级别，要求有事务，调用一方有事务就用调用方的，没有就新建一个事务；

3.NESTED，这个和REQUIRED有点像，调用一方有事务就新建一个嵌套事务加进去，没有就新建一个事务；

4.REQUIRES_NEW,要求有事务，要求还挺高，只要自己的新的事务，调用方有事务就挂起来；

5.MANDATORY，强制性的要求有事务，没有事务的方法一调用他就会抛异常；

6.NOT_SUPPORTED，没有事务，不管调用方有没有，咱不参与，就不支持事务这个功能；

7.NEVER，绝不，厌恶事务，有事务的方法调用他就抛异常；