事务的传播机制

1、MANDATORY：中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。
2、NESTED：嵌套事务，如果当前事务存在，那么在嵌套的事务中执行。如果当前事务不存在，则表现跟REQUIRED一样。
3、NEVER：无事务执行，如果当前有事务则抛出Exception。
4、NOT_SUPPORTED：无事务执行，如果当前事务存在，把当前事务挂起。
5、REQUIRED（默认）：支持使用当前事务，如果当前事务不存在，创建一个新事务。
6、REQUIRES_NEW：始终创建一个新事务，如果当前事务存在，把当前事务挂起。
7、SUPPORTS：支持使用当前事务，如果当前事务不存在，则不使用事务。

测试场景：外层方法和内层方法在不同的类里，外层调用内层先执行成功，外层再报错不try catch，

1》外层设置为 MANDATORY ，无论内层传播机制设置为什么，结果都一样，报错；需要一个更外层的有事务的方法调用外层才行；
						
2》外层设置为 NESTED ， 
  内层为 MANDATORY 时， 一起回滚了；（外层 NESTED 有事务，内层 MANDATORY ，但外层异常了，一起回滚）
  内层为 NESTED 时， 一起回滚了；（外层 NESTED 有事务，内层 NESTED ，但外层异常了，一起回滚）
  内层为 NEVER 时，报的错是有事务的错；（外层 NESTED 有事务，内层 NEVER 不需要事务，所以内层抛有事务异常）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚；（外层 NESTED 有事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，一起回滚了；（外层 NESTED 有事务，内层 REQUIRED 使用当前事务，所以一起回滚了）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚；（外层 NESTED 有事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，一起回滚了；（外层 NESTED 有事务，内层 SUPPORTS 支持当前事务，所以一起回滚了）

3》外层设置为 NEVER ，
  内层为 MANDATORY 时， 一起回滚了；报的错是没事务的错；（外层 NEVER 无事务，所以内层 MANDATORY 会抛异常）
  内层为 NESTED 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层会有个 NESTED 事务提交）
  内层为 NEVER 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层 NEVER 无事务提交）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层 REQUIRED 新建事务提交）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，内层提交成功，外层回滚了；（外层 NEVER 无事务，内层 SUPPORTS 无事务提交）

4》外层设置为 NOT_SUPPORTED ，
  内层为 MANDATORY 时， 一起回滚了；报的错是没事务的错；（外层 NOT_SUPPORTED 无事务，所以内层 MANDATORY 会抛异常）
  内层为 NESTED 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层会有个 NESTED 事务提交）
  内层为 NEVER 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层 NEVER 无事务提交）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层 REQUIRED 新建事务提交）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，内层提交成功，外层回滚了；（外层 NOT_SUPPORTED 无事务，内层 SUPPORTS 无事务提交）

5》外层设置为 REQUIRED ， 
  内层为 MANDATORY 时，一起回滚了；（外层 REQUIRED 有事务，内层 MANDATORY 使用当前事务，外层出错了，所以一起回滚）
  内层为 NESTED 时，一起回滚了；（外层 REQUIRED 有事务，内层 NESTED 嵌套事务（没有新建事务），外层出错了，所以一起回滚）
  内层为 NEVER 时，一起回滚了；（外层 REQUIRED 有事务，内层 NEVER 抛有事务的异常）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚了；（外层 REQUIRED 有事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，一起回滚了；（外层 REQUIRED 有事务，内层 REQUIRED 使用当前事务，外层出错了，所以一起回滚）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚了；（外层 REQUIRED 有事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，一起回滚了；（外层 REQUIRED 有事务，内层 SUPPORTS 使用当前事务，外层出错了，所以一起回滚）

6》外层设置为 REQUIRES_NEW ，
  内层为 MANDATORY 时， 一起回滚了；（外层 REQUIRES_NEW 有事务，内层 MANDATORY 使用当前事务，外层出错了，所以一起回滚）
  内层为 NESTED 时，一起回滚了；（外层 REQUIRES_NEW 有事务，内层 NESTED 嵌套事务（没有新建事务），外层出错了，所以一起回滚）
  内层为 NEVER 时，一起回滚了；（外层 REQUIRES_NEW 有事务，内层 NEVER 抛有事务的异常）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚了；（外层 REQUIRES_NEW 有事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，一起回滚了；（外层 REQUIRES_NEW 有事务，内层 REQUIRED 使用当前事务，外层出错了，所以一起回滚）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚了；（外层 REQUIRES_NEW 有事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，一起回滚了；（外层 REQUIRES_NEW 有事务，内层 SUPPORTS 使用当前事务，外层出错了，所以一起回滚）

7》外层设置为 SUPPORTS（支持使用当前事务，如果当前事务不存在，则不使用事务。其他地方没有把事务传播过来的情况，就是没有事务；当前情况是无事务）， 
  内层为 MANDATORY 时， 一起回滚了；（外层 SUPPORTS 支持事务，内层 MANDATORY 报没有事务的错）
  内层为 NESTED 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 NESTED 嵌套事务（新建事务）提交）
  内层为 NEVER 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 NEVER 无事务提交）
  内层为 NOT_SUPPORTED 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 NOT_SUPPORTED 无事务提交）
  内层为 REQUIRED 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 REQUIRED 新建事务提交）
  内层为 REQUIRES_NEW 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 REQUIRES_NEW 新建事务提交）
  内层为 SUPPORTS 时，内层提交成功，外层回滚了；（外层 SUPPORTS 支持事务，内层 SUPPORTS 无事务提交）

//TestDao类里的方法：
@Transactional(propagation=Propagation.SUPPORTS)
	public void insertA(){
		testDao2.insertC();

		TransactionStatus st = TransactionAspectSupport.currentTransactionStatus();
		logger.info("----当前事务状态："+st.hashCode()+"-----"+st.isNewTransaction());
		String sql = "INSERT INTO T_TEST_ONE(SYSCODE,SYSNAME,NUM) VALUES(?,?,?)";
		//这里插入时，故意把字符“1a”插入一个数据库为数字的字段，引发异常
		Object[] obj1 = new Object[]{"1","1","1a"};
		amsJdbcTemplate.update(sql, obj1);
	}

//TestDao2类里的方法
@Transactional(propagation=Propagation.SUPPORTS)
	public void insertC(){
		TransactionStatus st = TransactionAspectSupport.currentTransactionStatus();
		logger.info("----当前事务状态："+st.hashCode()+"-----"+st.isNewTransaction());
		String sql = "INSERT INTO T_TEST_ONE(SYSCODE,SYSNAME,NUM) VALUES(?,?,?)";
		Object[] obj = new Object[]{"3","3","3"};
		amsJdbcTemplate.update(sql, obj);
	}

//main方法调用
public static void main(String[] args) {
		try{
			ApplicationContext atc = new FileSystemXmlApplicationContext("/WebRoot/WEB-INF/applicationContext.xml");
			TestDao ts = (TestDao)atc.getBean("testDaoId");
			try{
				ts.insertA();
			}catch(Exception e){
				logger.info("----aaaaaaaaaaaaaa----------",e);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
}