spring-transaction-propagation

Spring 事务：是spring 通过 aop实现的一套事务管理功能，可以定义隔离级别，传播行为，回滚规则，事务超时，是否只读。

1、隔离级别 对应mysql 几乎都是定义为 可重复读

2、传播特性则不同，不同的业务场景，使用的特性非常不同

 

spring 事务的创建的时间点：通过aop 在调用需要开启事务的方法前开启，方法结束后提交事务（准确的说还要看事务的传播行为），或者抛出异常回滚事务

 

事务传播行为（Transaction Propagation Behavior）：定义当前方法的事务和调用方事务的关系，比如：可以加入到调用方的事务，也可以重新开启事务，亦或开始事务保存点等。

 

 Spring 提供的几种事务传播行为：

1.PROPAGATION_REQUIRED（加入已有事务）

    尝试加入已经存在的事务中，如果没有则开启一个新的事务。

注意：如果这个事务回滚，因为和调用方使用的是一个事务，所以调用方的事务同时回滚，这一点也是和nested事务的区别之处 （这里都是说内层的事务传播特性，调用方已经开启了事务）

2.RROPAGATION_REQUIRES_NEW（独立事务）

    挂起当前存在的事务，并开启一个全新的事务，新事务与已存在的事务之间彼此没有关系。

  注意：如果做到没有任何关系 ?重新启动一个connection连接，和当前连接没有关系，自然事务也完全隔离了

3.PROPAGATION_NESTED（嵌套事务）

    在当前事务上开启一个子事务（Savepoint），如果递交主事务。那么连同子事务一同递交。如果递交子事务则保存点之前的所有事务都会被递交。

注意：嵌套事务本身不会开启新的事务，即用的是已经存在的事务，nested事务抛出异常，调用方捕获异常，则调用方的事务不会回滚（savepoint特性）；当然如果继续抛出或者调用方没有捕获异常亦或调用方有异常，都回滚（这里都是说内层的事务传播特性，调用方已经开启了事务）

 

更专业的描述为：嵌套事务：就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

 

4.PROPAGATION_SUPPORTS（跟随环境）

    是指 Spring 容器中如果当前没有事务存在，就以非事务方式执行；如果有，就使用当前事务。

5.PROPAGATION_NOT_SUPPORTED（非事务方式）

    是指如果存在事务则将这个事务挂起，并使用新的数据库连接。新的数据库连接不使用事务。

6.PROPAGATION_NEVER（排除事务）

    当存在事务时抛出异常，否则就已非事务方式运行。

7.PROPAGATION_MANDATORY（需要事务）

    如果不存在事务就抛出异常，否则就已事务方式运行。

 

其中第4-7的事务行为比较简单，不再详述；最应该引起重视的是：RROPAGATION_REQUIRES_NEW ，当前方法启动的事务和调用方的事务没有关系，他和调用方的数据库连接都不是一个。

 

 如果有时间，最好运行下下面的用例，仔细体会下不同事务的传播属性的实际情况：

测试用例：

/**
 * @author xinchun.wang
 */
@Service
public class UserDaoImpl  {

	@Resource
	private JdbcTemplate jdbcTemplate;
	
	
	
	public void testWithOutTransaction() {
		String info = "testWithOutTransaction_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
	}
	
	/**
	 *  挂起当前存在的事务，并开启一个全新的事务，新事务与已存在的事务之间彼此没有关系。
	 */
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRES_NEW)
	public void testTransactionNew() {
		String info = "Afater_insertLoginLog_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
		Connection connection = ((ConnectionHolder)(TransactionSynchronizationManager.getResourceMap().values().iterator().next())).getConnection();
		System.out.println("$$$$$$$"+connection.hashCode());
	}

	
	
	/**
	 * 尝试加入已经存在的事务中，如果没有则开启一个新的事务。
	 */
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRED)
	public void testTransactionRequired() {
		String info = "Before_tesTransactionRequired_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
		
		if(true){
			throw new RuntimeException("Error");
		}
		
		info = "After_tesTransactionRequired_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
		
	}
	
	
	
	/**
	 *   在当前事务上开启一个子事务（Savepoint），如果递交主事务。那么连同子事务一同递交。如果递交子事务则保存点之前的所有事务都会被递交。
	 */
	@Transactional(value = "transactionManager",propagation=Propagation.NESTED)
	public void testNestTransactionWithException() {
		String info = "testNestTransactionWithException_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
		if(true){
			throw new RuntimeException("Error");
		}
	}

	
	/**
	 *   在当前事务上开启一个子事务（Savepoint），如果递交主事务。那么连同子事务一同递交。如果递交子事务则保存点之前的所有事务都会被递交。
	 */
	@Transactional(value = "transactionManager",propagation=Propagation.NESTED)
	public void testNestTransaction() {
		String info = "testNestTransaction_"+System.currentTimeMillis() + UUID.randomUUID().toString();
		jdbcTemplate.execute("INSERT INTO user_log(info, `time`) VALUES ( '"+info+"','"+info+"')");
		UserServiceImpl.printData("&&&&&&&&&&");
	}
	
	
}

 

/**
 * @author xinchun.wang
 */
@Service
public class UserServiceImpl implements IUserService {

	@Resource
	private UserDaoImpl userDaoImpl;
	
	/**
	 *  挂起当前存在的事务，并开启一个全新的事务，新事务与已存在的事务之间彼此没有关系。
	 */
	@Override
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRED)
	public void testTransactionNew() {
		userDaoImpl.testWithOutTransaction();
		Connection connection = ((ConnectionHolder)(TransactionSynchronizationManager.getResourceMap().values().iterator().next())).getConnection();
		System.out.println("#######"+connection.hashCode());
		userDaoImpl.testTransactionNew();
		userDaoImpl.testTransactionRequired();
	}

	

	/**
	 * 嵌套事务失败，外部事务捕获异常，可以正常提交
	 * start transaction
	 *  insert data1
	 *  save savepoint1
	 *  insert data2
	 *  roback savepoint1
	 *  commit
	 */
	@Override
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRED)
	public void testNestTransactionWithException() {
		userDaoImpl.testWithOutTransaction();
		try{
			userDaoImpl.testNestTransactionWithException();
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	
	/**
	 * 
	 * 调用者出现unchecked异常,却能触发所调用的nested事务的回滚.(外部事务失败，都取消)
	 * start transaction
	 *  insert data1
	 *  save savepoint1
	 *  insert data2
	 *  rollback
	 */
	@Override
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRED)
	public void testNestTransaction() {
		UserServiceImpl.printData("########");
		userDaoImpl.testWithOutTransaction();
		userDaoImpl.testNestTransaction();
		
		if(true){
			throw new RuntimeException("Error");
		}
	}
	
	
	@Override
	@Transactional(value = "transactionManager",propagation=Propagation.REQUIRED)
	public void testTransactionRequared() {
		System.out.println(TransactionSynchronizationManager.getResourceMap().values());
		Connection connection = ((ConnectionHolder)(TransactionSynchronizationManager.getResourceMap().values().iterator().next())).getConnection();
		System.out.println("$$$$$$$"+connection.hashCode());
		userDaoImpl.testWithOutTransaction();
		try{
			userDaoImpl.testTransactionRequired();
		}catch(Exception e){
			
		}
	}
	
	
	/** 通过这个，可以确定当前连接的hashcode*/
	public static void printData(String key){
		System.out.println(TransactionSynchronizationManager.getResourceMap().values());
		Connection connection = ((ConnectionHolder)(TransactionSynchronizationManager.getResourceMap().values().iterator().next())).getConnection();
		
		System.out.println(key+connection.hashCode());
	}
}

 

 

最后：在事务修饰的方法内部，直接调用事务修饰的方法，如果没有通过aop代理来调用，不会有事务，也不会是一个数据库连接。