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代理来调用，不会有事务，也不会是一个数据库连接。