Spring事务传播行为代码示例

最新推荐文章于 2023-09-19 21:23:38 发布
最新推荐文章于 2023-09-19 21:23:38 发布
阅读量129 收藏
点赞数
分类专栏： 数据库 文章标签： spring 数据库 java
原文链接：https://segmentfault.com/a/1190000013341344
版权
01 前言：
  1. 建议先阅读原作者JerryTse关于spring事务传播行为的详解 ：Spring事务传播行为详解
  2. 该部分代码源于https://github.com/TmTse/transaction-test，对注释位置进行了部分调整，方便阅读。

02 代码背景：

模拟向user1、user2两张数据库表中插入数据，演示使用不同的事务传播行为，在不同的位置模拟产生异常，观察不同位置的异常对事务传播行为的影响。


03 示例代码中方法名解释：
// 外层方法名示例：
	notransaction_required_required()
	第一个位置表示外层方法是否有事务、后面依次是内层被调用的方法的事务传播行为。
	
	transaction_exception_notransaction_notransaction()
	表示外层方法有事务（第一个位置），且有异常（第二个位置），内层调用的两个方法都没有事务（第三、第四个位置）
	
	notransaction_exception_required_required()
	表示外层方法没有事务（第一个位置），且有异常（第二个位置），内层调用的两个方法的事务传播行为已设置为required（第三、四个位置）


// 内层方法名示例：
	addRequired()
	表示该方法的事务传播行为已设置为required
	addRequiredException(user2);
	表示该方法的事务传播行为已设置为required，且方法执行时会产生异常



04 示例代码：
package org.transaction.test.local_transaction.mybatis.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.transaction.test.local_transaction.mybatis.bean.User1;
import org.transaction.test.local_transaction.mybatis.bean.User2;
import org.transaction.test.local_transaction.mybatis.service.TransactionPropagationExample;
import org.transaction.test.local_transaction.mybatis.service.User1Service;
import org.transaction.test.local_transaction.mybatis.service.User2Service;

@Service
public class TransactionPropagationExampleImpl implements TransactionPropagationExample {
	@Autowired
	private User1Service user1Service;
	@Autowired
	private User2Service user2Service;
	
	
	@Override
	public void truncated() {
		user1Service.truncate();
		user2Service.truncate();
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 */
	@Override
	public void notransaction_exception_notransaction_notransaction(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.add(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.add(user2);
		throw new RuntimeException();
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 */
	@Override
	public void notransaction_notransaction_notransaction_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.add(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addException(user2);
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，外围方法内的方法就应该在同一个事务中。外围方法抛出异常，整个事务所有方法都会被回滚。
	 */
	@Override
	@Transactional
	public void transaction_exception_notransaction_notransaction(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.add(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.add(user2);
		throw new RuntimeException();
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，外围方法内的方法就应该在同一个事务中。内部方法抛出异常，被外围方法捕获，整个事务中所有方法都会被回滚。
	 */
	@Override
	@Transactional
	public void transaction_notransaction_notransaction_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.add(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addException(user2);
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 观察方法执行，执行完插入“张三”方法后数据库即插入数据，执行完插入“李四”方法后数据库即插入数据，结合后面回滚方法，说明两个方法分别在两个事务中执行。
	 */
	@Override
	public void notransaction_required_required(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequired(user2);
	}

	/**
	 * 结果：getRequired可见，get可见</br>
	 * 外围方法未开启事务，addRequired在自己的事务中运行，执行外之后即对外可见，故getRequired和get都可见事务执行结果。
	 */
	@Override
	public void notransaction_addRequired_getRequired_get(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		User1 temp1=user1Service.getRequired(1);
		if(temp1!=null){
			System.out.println("getRequired可见");
		}
		User1 temp2=user1Service.get(1);
		
		if(temp2!=null){
			System.out.println("get可见");
		}
	}

	/**
	 * 结果：张三（插入），李四（插入）。</br>
	 * 外围方法没有事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。
	 */
	@Override
	public void notransaction_exception_required_required(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequired(user2);
		
		throw new RuntimeException();
	}


	/**
	 * 结果：张三（插入），李四（未插入）</br>
	 * 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”
	 * 方法不受影响。
	 *
	 */
	@Override
	public void notransaction_required_required_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiredException(user2);
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”、“李四”方法都在外围方法的事务中运行，加入外围方法事务，所以三个方法同一个事务。外围方法或内部方法抛出异常，
	 * 整个事务全部回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_exception_required_required(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequired(user2);
		
		throw new RuntimeException();
	}


	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”、“李四”方法都在外围方法的事务中运行，加入外围方法事务，所以三个方法同一个事务。外围方法或内部方法抛出异常，
	 * 整个事务全部回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_required_required_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiredException(user2);
	}

	/**
	 * 结果：getRequired可见，get可见</br>
	 * 外围方法开启事务，addRequired和外围方法同事务，getRequired和get都和外围方法同一个事务，故均可见addRequired执行之后的结果。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_addRequired_getRequired_get(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User1 temp1=user1Service.getRequired(1);
		if(temp1!=null){
			System.out.println("getRequired可见");
		}
		User1 temp2=user1Service.get(1);
		
		if(temp2!=null){
			System.out.println("get可见");
		}
		
	
	}

	/**
	 * 结果：getNested可见，get可见</br>
	 * 外围方法开启事务，addRequired和外围方法同事务，getNested属于外围事务子事务，get属于外围事务，故均可见addRequired执行之后的结果。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_addRequired_getNested_get(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User1 temp1=user1Service.getNested(1);
		if(temp1!=null){
			System.out.println("getNested可见");
		}
		User1 temp2=user1Service.get(1);
		
		if(temp2!=null){
			System.out.println("get可见");
		}
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”、“李四”方法也均未开启事务，因为不存在事务所以无论外围方法或者内部方法抛出异常都不会回滚。
	 */
	@Override
	public void notransaction_supports_supports_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addSupports(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addSupportsException(user2);
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”、“李四”方法也均未开启事务，因为不存在事务所以无论外围方法或者内部方法抛出异常都不会回滚。
	 */
	@Override
	public void notransaction_exception_supports_supports(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addSupports(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addSupports(user2);
		throw new RuntimeException();
		
	}
	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”、“李四”方法都在外围方法的事务中运行，加入外围方法事务，所以三个方法同一个事务。外围方法或内部方法抛出异常，
	 * 整个事务全部回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_supports_supports_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addSupports(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addSupportsException(user2);
	}
	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”、“李四”方法都在外围方法的事务中运行，加入外围方法事务，所以三个方法同一个事务。外围方法或内部方法抛出异常，
	 * 整个事务全部回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_exception_supports_supports(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addSupports(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addSupports(user2);
		
		throw new RuntimeException();
	}


	/**
	 * 结果：张三（插入），李四（未插入）</br>
	 * 外围方法未开启事务，插入“张三”、“李四”方法都在自己的事务中独立运行。插入“李四”方法抛出异常只会导致插入“李四”方法中的事务被回滚，
	 * 不会影响插入“张三”方法的事务。
	 */
	@Override
	public void notransaction_requiresNew_requiresNew_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequiresNew(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiresNewException(user2);
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”、“李四”方法都在自己的事务中独立运行。外围方法抛出异常，插入“张三”、“李四”事务均不回滚。
	 */
	@Override
	public void notransaction_exception_requiresNew_requiresNew(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequiresNew(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiresNew(user2);
		throw new RuntimeException();
		
	}
	/**
	 * 结果：张三（未插入），李四（插入），王五（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入
	 * “王五”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被回滚，故插入“张三”方法也被回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_required_requiresNew_requiresNew_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiresNew(user2);
		
		User2 user3=new User2();
		user3.setName("王五");
		user2Service.addRequiresNewException(user3);
	}

	/**
	 * 结果：张三（插入），李四（插入），王五（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入
	 * “王五”方法的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“张三”方法插入成功。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_required_requiresNew_requiresNew_exception_try(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiresNew(user2);
		User2 user3=new User2();
		user3.setName("王五");
		try {
			user2Service.addRequiresNewException(user3);
		} catch (Exception e) {
			System.out.println("回滚");
		}
	}
	/**
	 * 结果：张三（未插入），李四（插入），王五（插入）</br>
	 * 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中，
	 * 外围方法抛出异常只回滚和外围方法同一事务的方法，故插入“张三”的方法回滚。
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void transaction_exception_required_requiresNew_requiresNew(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addRequiresNew(user2);
		
		User2 user3=new User2();
		user3.setName("王五");
		user2Service.addRequiresNew(user3);
		
		throw new RuntimeException();
	}


	/**
	 * 结果：get可见</br>
	 * 外围方法开启事务，addRequired和外围方法同事务，getRequiresNew新开事务，并将外围事务挂起，由于事务隔离性，getRequiresNew看不到addRequired的执行结果。
	 * ，get属于外围事务，故可见addRequired执行之后的结果。
	 */
	@Transactional
	@Override
	public void transaction_addRequired_getRequiresNew_get(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User1 temp1=user1Service.getRequiresNew(1);
		if(temp1!=null){
			System.out.println("getRequiresNew可见");
		}
		User1 temp2=user1Service.get(1);
		
		if(temp2!=null){
			System.out.println("get可见");
		}
	}


	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”方法在自己的事务中运行，插入“李四”方法不在任何事务中运行。外围方法抛出异常，但是外围方法没有事务，
	 * 所以其他内部事务方法不会被回滚，非事务方法更不会被回滚。
	 *
	 */
	@Override
	public void notransaction_exception_required_notSuppored(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNotSupported(user2);
		throw new RuntimeException();
	}
	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”方法在自己的事务中运行，插入“李四”方法不在任何事务中运行。外围方法抛出异常，但是外围方法没有事务，
	 * 所以其他内部事务方法不会被回滚，非事务方法更不会被回滚。
	 *
	 */
	@Override
	public void notransaction_required_notSuppored_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNotSupportedException(user2);
	}
	/**
	 * 结果：张三（未插入），李四（插入）</br>
	 * 外围方法开启事务，因为插入“张三”方法传播为required，所以和外围方法同一个事务。插入“李四”方法不在任何事务中运行。
	 * 外围方法抛出异常，外围方法所在的事务将会回滚，因为插入“张三”方法和外围方法同一个事务，所以将会回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_exception_required_notSuppored(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNotSupported(user2);
		throw new RuntimeException();
	}
	/**
	 * 结果：张三（未插入），李四（插入）</br>
	 * 外围方法开启事务，因为插入“张三”方法传播为required，所以和外围方法同一个事务。插入“李四”方法不在任何事务中运行。
	 * 插入“李四”方法抛出异常，因为此方法不开启事务，所以此方法不会被回滚，外围方法接收到了异常，所以外围事务需要回滚，因插入“张三”
	 * 方法和外围方法同一事务，故被回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_required_notSuppored_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNotSupportedException(user2);
	}


	/**
	 * 结果：get可见</br>
	 * 外围方法开启事务，addRequired和外围方法同事务，getNotSuppored不支持事务，并将外围事务挂起，getNotSuppored不在addRequired事务范围中，由于事务隔离性，getNotSuppored看不到addRequired的执行结果。
	 * ，get属于外围事务，故可见addRequired执行之后的结果。
	 */
	@Transactional
	@Override
	public void transaction_addRequired_getNotSuppored_get(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User1 temp1=user1Service.getNotSupported(1);
		if(temp1!=null){
			System.out.println("getRequired可见");
		}
		User1 temp2=user1Service.get(1);
		
		if(temp2!=null){
			System.out.println("get可见");
		}
	}

	/**
	 * 结果：张三（未插入）</br>
	 * 外围方法未开启事务。内部插入“张三”方法执行的时候因外围没有事务而直接抛出异常，具体插入方法都没有机会执行。
	 *
	 */
	@Override
	public void notransaction_mandatory(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addMandatory(user1);
	}
	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法都加入外围方法事务，外围方法抛出异常，事务回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_exception_mandatory_mandatory(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addMandatory(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addMandatory(user2);
		throw new RuntimeException();
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法都加入外围方法事务，内部方法抛出异常，整个事务回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_mandatory_mandatory_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addMandatory(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addMandatoryException(user2);
	}



	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”方法和插入“李四”方法也均无事务，任何异常都不会回滚。。
	 *
	 */
	@Override
	public void notransaction_exception_never_never(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNever(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNever(user2);
		throw new RuntimeException();
	}
	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法未开启事务，插入“张三”方法和插入“李四”方法也均无事务，任何异常都不会回滚。。
	 *
	 */
	@Override
	public void notransaction_never_never_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNever(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNeverException(user2);
	}
	/**
	 * 结果：张三（未插入</br>
	 * 外围方法开启事务。内部插入“张三”方法执行的时候因外围有事务而直接抛出异常，具体插入方法都没有机会执行。
	 *
	 */
	@Transactional
	@Override
	public void transaction_never(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNever(user1);
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法为外围方法的子事务，外围方法事务回滚，相应的子事务也会回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_exception_nested_nested(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNested(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNested(user2);
		throw new RuntimeException();
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法为外围方法的子事务，插入“李四”方法抛出异常，相应的子事务回滚，异常被外围方法感知，外围方法事务回滚，其他子事务即插入“张三”方法事务也回滚了。
	 *
	 */
	@Transactional
	@Override
	public void transaction_nested_nested_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNested(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNestedException(user2);
	}


	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法为开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，外围方法事务回滚，所有方法均不回滚。
	 *
	 */
	@Override
	public void notransaction_exception_nested_nested(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNested(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNested(user2);
		throw new RuntimeException();
	}
	/**
	 * 结果：张三（插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，插入“李四”方法抛出异常，相应的子事务回滚，异常被外围方法感知，外围方法无事务所以无需回滚，故插入“张三”方法没有回滚。
	 *
	 */
	@Override
	public void notransaction_nested_nested_exception(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNested(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		user2Service.addNestedException(user2);
	}
	/**
	 * 结果：张三（插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”方法和插入“李四”方法为外围方法的子事务，插入“李四”方法抛出异常，相应的子事务回滚，异常被捕获外围方法不可知，故外围方法事务无需回滚。
	 *
	 */
	@Transactional
	@Override
	public void transaction_nested_nested_exception_try(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addNested(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		try {
			user2Service.addNestedException(user2);
		} catch (Exception e) {
			System.out.println("方法回滚");
		}
	}

	/**
	 * 结果：张三（未插入），李四（未插入）</br>
	 * 外围方法开启事务，插入“张三”、“李四”方法都在外围方法的事务中运行，加入外围方法事务，所以三个方法同一个事务。外围方法或内部方法抛出异常，
	 * 整个事务全部回滚。虽然我们catch了插入“李四”方法的异常，使异常不会被外围方法感知，但是插入“李四”方法事务被回滚，内部方法外围方法一个事务，所以整体事务被回滚了。
	 */
	@Transactional
	@Override
	public void transaction_required_required_exception_try(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.addRequired(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		try {
			user2Service.addRequiredException(user2);
		} catch (Exception e) {
			System.out.println("方法回滚");
		}
	}

	/**
	 * 结果：张三（插入），李四（插入）</br>
	 * 外围方法开启事务，内部方法都在同一事务中，只要不抛出异常，事务就不会回滚。
	 */
	@Transactional
	@Override
	public void transaction_noTransaction_noTransaction_exception_try(){
		User1 user1=new User1();
		user1.setName("张三");
		user1Service.add(user1);
		
		User2 user2=new User2();
		user2.setName("李四");
		try {
			user2Service.addException(user2);
		} catch (Exception e) {
			System.out.println("方法回滚");
		}
	}
}
我爱喝酸奶♂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Spring事务传播行为实战
08-25
本文主要介绍了浅谈Spring事务传播行为实战，通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。需要的朋友们可以根据自己的需求，选择适合的事务传播机制，提高程序的响应速度，并且避免...
Spring中的事务传播行为示例详解
08-25
Spring中的事务传播行为示例详解 Spring 框架中事务传播行为是指在多个方法之间的调用关系中，...这篇文章主要通过示例代码介绍了 Spring 中的事务传播行为，希望对大家学习或者使用 Spring 有一定的参考学习价值。
spring 事务传播行为实例分析
码农的世界你不懂
02-28 4万+
欢迎转载和指正，转载时请说明来源
spring事务传播机制代码演示
my的博客
09-15 168
highlight: androidstudio spring事务传播，我在面试中被问到很多次，所以有必要学习一下。还有分布式事务，真的是问惨了~~~ (一) 先看下spring中有哪些事务传播级别 1. REQUIRED ( Spring默认的事务传播类型 ) 支持当前事务，如果当前没有事务，则新建事务 如果当前存在事务，则加入当前事务，合并成一个事务 2. SUPPORTS ...
Spring事务传播机制示例代码与详解
王鹏鹏-软件研发工程师
06-30 432
Spring事务传播机制示例代码与详解 最直观例子 ：下单买书业务 两个事务方法（checkout，purchase） username代表用户名 isbns代表购买多本书的集合 @Transactional @Override public void checkout(String username, List<String> isbns) { for(String isbn: isbns){ bookShopService.purchase(username, isb
Spring事务7种传播机制（代码示例）
谢文峰的博客
12-30 1157
Spring事务7种传播机制（代码示例） 文章目录Spring事务7种传播机制（代码示例）前言1.项目环境2.相关资料2.1 Spring 源码2.2 官网地址3.示例代码3.1 无事务示例3.1.1 正常示例3.1.2 异常示例3.2 REQUIRED（默认）3.2.1 代码示例3.2.2 结果分析3.3 REQUIRES_NEW3.3.1 代码示例3.3.2 结果分析3.4 SUPPORTS3.4.1 代码示例3.4.2 结果分析3.5 MANDATORY3.5.1 代码示例3.5.2 结果分析3.6
Spring事务传播行为详解（示例版）
H.CF的博客
03-09 148
Spring中七种事务传播行为 代码验证 文中代码以传统三层结构中两层呈现，即Service和Dao层，由Spring负责依赖注入和注解式事务管理，DAO层由Mybatis实现，你也可以使用任何喜欢的方式，例如，Hibernate,JPA,JDBCTemplate等。数据库使用的是MySQL数据库，你也可以使用任何支持事务的数据库，并不会影响验证结果。 首先我们在数据库中创建两张表： -- u...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
深入理解Spring的事务传播行为
08-27
【Spring的事务传播行为详解】 在Spring框架中，事务传播行为是其事务管理的一大特色，它定义了在多个具有事务控制的服务之间相互调用时如何处理事务边界。这有助于解决在分布式系统中复杂的事务管理问题。Spring...
spring-tx:spring 事务传播示例
06-29
本篇将深入探讨Spring事务传播行为，以及如何在实际应用中进行配置和使用。 1. **事务传播行为** Spring事务管理支持7种不同的事务传播行为，这些行为定义了一个事务方法在被另一个事务方法调用时应该如何处理： ...
18个示例详解 Spring 事务传播机制(附测试源码)
qq_42700121的博客
01-18 442
什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在 Propagation 枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 MANDATORY 强制
Spring事务的7种传播机制实例代码及分析
smlie_shuihan的博客
06-05 477
spring定义了7中事务传播机制 REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED) SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS) MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY) REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW) NOT_SUPPORTED(Tr
手把手利用实战代码带你读懂Spring的事务传播行为
xyl的博客
03-17 387
结果解析：insertStudent()，insertClassByException() 方法执行时，外部方法事务被挂起，内部方法会新建事务，直至该方法执行结束，恢复外部方法事务执行。结果：外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被 catch 不被外围方法感知，整个事务依然回滚。由于外部方法并没有开启事务，所以内部方法均在自己的事务提交或者回滚，因此外部方法中存在异常，内部方法事务不会回滚。方法，则以非事务执行，即使后面存在异常情况，执行操作结果不会触发事务回滚机制。
Spring 事务和事务的传播机制
Node_Hao的博客
07-22 785
将一组操作封装成一个执行单元 (分装到一起) , 要么全部成功 , 要么全部失败.Spring 事务的传播机制是指多个事务方法相互调用(嵌套)的情况下 , 如何管理这些事务的提交和回滚.
Spring 事务和事务传播机制
kaiwawah的博客
05-18 861
事务就是将一组操作封装成一个执行单元（封装到一起），要么一起成功，要么一起失败。在打账的情景上，A向B转账200 元，A的账户-200.B的账号+200，但是如果是一些特殊情况，A的账号-200之后，但是B账号并没有加上这个200元子的话，就会出现很大的问题，而出现这一大问题的原因，就是没有将转账这个业务变成事务。这里也体现了事务的原子性一大特征。
Spring事务传播机制详细讲解
qq_39939541的博客
08-01 2074
事务传播机制允许开发者根据实际需求来控制事务的行为。通过合理选择事务传播机制，可以保证事务的一致性和可靠性，提高系统的稳定性和性能。需要注意的是，事务传播机制只对方法级别的事务起作用，对注解方式的事务不适用。在使用注解方式时，可以通过@Transactional注解的propagation属性来指定事务的传播行为。
Spring事务传播机制-通俗易懂
qq_42137703的博客
02-16 272
Spring事务传播机制
spring中事务的传播行为详解+业务场景示例
最新发布
qq_41717518的博客
09-19 1433
这里我先来给大家规整一下代码，涉及事务传播行为要点的是UserServiceImpl的register方法，这里为了后续方便指认，我就称UserServiceImpl的register方法为外围方法。
Spring事务管理（详解+实例）
热门推荐
Trigl的博客
03-25 8万+
写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）
spring 事务的传播行为 代码示例
06-09
Spring事务传播行为是指在某个事务方法调用另一个事务方法时，如何处理这两个事务之间的关系，常见的传播行为有以下几种： 1. REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值