最近在开发中对Spring中的事务标记@Transactional用的比较多，今天上网收集了一些内容，做一个简单的总结~~~
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。
Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这个例外是unchecked
如果遇到checked意外就不回滚。
如何改变默认规则：
1 让checked例外也回滚：在整个方法前加上 @Transactional(rollbackFor=Exception.class)
2 让unchecked例外不回滚： @Transactional(notRollbackFor=RunTimeException.class)
3 不需要事务管理的(只查询的)方法：@Transactional(propagation=Propagation.NOT_SUPPORTED)
如果在整个方法运行前就不会开启事务
还可以加上：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)，这样就做成一个只读事务，可以提高效率。
此外需要注意： 如果异常被try｛｝catch｛｝了，事务就不回滚了，如果想让事务回滚必须再往外抛try｛｝catch｛throw Exception｝。
各种属性的意义：
REQUIRED:业务方法需要在一个容器里运行。如果方法运行时，已经处在一个事务中，那么加入到这个事务，否则自己新建一个新的事务。
NOT_SUPPORTED:声明方法不需要事务。如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。
REQUIRESNEW:不管是否存在事务，该方法总汇为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务挂起，新的事务被创建。
MANDATORY：该方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果在没有事务的环境下被调用，容器抛出例外。
SUPPORTS:该方法在某个事务范围内被调用，则方法成为该事务的一部分。如果方法在该事务范围外被调用，该方法就在没有事务的环境下执行。
NEVER：该方法绝对不能在事务范围内执行。如果在就抛例外。只有该方法没有关联到任何事务，才正常执行。
NESTED:如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对
DataSourceTransactionManager事务管理器起效。
// 如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
@Transactional(propagation=Propagation.REQUIRED)
// 容器不为这个方法开启事务
@Transactional(propagation=Propagation.NOT_SUPPORTED)
// 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
// 必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.MANDATORY)
// 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.NEVER)
// 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
@Transactional(propagation=Propagation.SUPPORTS)
@Transactional(propagation=Propagation.NESTED)
// readOnly=true只读,不能更新,删除
@Transactional (propagation = Propagation.REQUIRED,readOnly=true)
// 设置超时时间
@Transactional (propagation = Propagation.REQUIRED,timeout=30)
// 设置数据库隔离级别
@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)
@Transactional设置：
propagation：事务传播性设置，Propagation枚举类型。Spring支持的事务传播属性包括7种：
PROPAGATION_MANDATORY：方法必须在事务中执行，否则抛出异常。
PROPAGATION_NESTED：使方法运行在嵌套事务中，否则和PROPAGATION_REQUIRED一样。
PROPAGATION_NEVER ：当前方法永远不在事务中运行，否则抛出异常。
PROPAGATION_NOT_SUPPORTED：定义为当前事务不支持的方法，在该方法执行期间正在运行的事务会被暂停
PROPAGATION_REQUIRED：当前的方法必须运行在事务中，如果没有事务就新建一个事务。新事务和方法一起开始，随着方法返回或者抛出异常时终止。
PROPAGATION_REQUIRED_NEW ：当前方法必须新建一个事务，如果当前的事务正在运行则暂停。
PROPAGATION_SUPPORTS ：规定当前方法支持当前事务，但是如果没有事务在运行就使用非事务方法执行。
isolation：事务隔离性级别设置，Isolation枚举类型
ISOLATION_DEFAULT ：使用数据库默认的隔离级别
ISOLATION_COMMITTED：允许其他事务已经提交的更新（防止脏读取）
ISOLATION_READ_UNCOMMITTED：允许读取其他事务未提交的更新，会导致三个缺陷发生。执行速度最快
ISOLATION_REPEATABLE_READ ：除非事务自身更改了数据，否则事务多次读取的数据相同（防止脏数据，多次重复读取）
ISOLATION_SERIALIZABLE：隔离级别最高，可以防止三个缺陷，但是速度最慢，影响性能。
readOnly：读写性事务，只读性事务，布尔型
对数据库的操作中，查询是使用最频繁的操作，每次执行查询时都要从数据库中重新读取数据，有时多次读取的数据都是相同的，这样的数据操作不仅浪费了系统资源，还影响了系统速度。对访问量大的程序来说，节省这部分资源可以大大提 升系统速度。
将事务声明为只读的，那么数据库可以根据事务的特性优化事务的读取操作
timeout：超时时间，单位秒
事务可能因为某种原因很长时间没有反应，这期间可能锁定了数据库表，影响性能。设置超时时间，如果超过该时间，事务自动回滚。
rollbackFor：一组异常类的实例，遇到时必须进行回滚
rollbackForClassname：一组异常类的名字，遇到时必须进行回滚
noRollbackFor：一组异常类的实例，遇到时必须不回滚
noRollbackForClassname：一组异常类的名字，遇到时必须不回滚
实例一：事务的回滚情况
1、默认情况对非运行时异常不进行回滚操作
/**
* 运行时异常默认事务回滚
* @throws Exception
*/
@Transactional
public void updateUser_1() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
throw new RuntimeException(); //抛出运行时异常 默认情况下回滚 事务---------------------->回滚
}
2、非运行时异常默认事务不回滚
/**
* 非运行时异常默认事务不回滚
* @throws Exception
*/
@Transactional
public void updateUser_3() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
throw new Exception(); //抛出非运行时异常 默认情况下不回滚 事务---------------------->不回滚
}
3、对所有异常事务都进行回滚操作
/**
* 对所有异常事务都进行回滚操作
* @throws Exception
*/
@Transactional(rollbackFor=Exception.class)
public void updateUser_6() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
throw new Exception(); //对所有异常事务都进行回滚操作 事务---------------------->回滚
}
4、对所有异常事务都不进行回滚操作
/**
* 对所有异常事务都不进行回滚操作
* @throws Exception
*/
@Transactional(noRollbackFor=Exception.class)
public void updateUser_7() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
throw new RuntimeException(); //对所有异常，事务都不进行回滚操作 事务---------------------->不回滚
}
实例二：对try{} catch{}的异常不回滚
/**
* 对于try{} catch{}的异常不进行回滚
* @throws Exception
*/
@Transactional
public void updateUser_5() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
try{
throw new RuntimeException(); //运行时异常被捕获，事务不回滚
}
catch(Exception e){
System.err.println("运行时异常被捕获，事务不回滚");
}
}
实例三：关于嵌套事务的回滚原则
说实话对于嵌套事务的测试，我现在仍然有一些疑问，比如说如果内部事务设置为
// 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
那这样的情况下，内部事务设置为Propagation.REQUIRES_NEW，外部事务设置为Propagation.REQUIRED，那么如果在内部事务执行完后之后，如果外部事务抛出了运行时异常，那么对于内部事务而言
由于是新开的一个单独的事务，这样的情况下内部事务应该不受外部事务的影响而回退，但是事实上经过测试，内部事务也是回滚的。感兴趣的同学可以一起探讨啊~
在网上找了一些博客，下面贴出一篇比较好嵌套事务的博客:
http://blog.chinaunix.net/uid-10289334-id-2964925.html
1、外部事务抛异常，内部事务回滚（一般来说，只要外部开启事务，内部方法无论是否开启事务，只要出现相应的运行时异常，事务都将进行回滚操作）
/**
* 测试事务的相关信息
* @throws Exception
*/
@Override
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void updateUser() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
insideMethod_01(); //1 、异常 不捕获 事务---------------------->回滚
// insideMethod_02(); //2、异常 捕获 事务---------------------->不回滚
throw new RuntimeException(); //3、测试外部方法抛异常 事务---------------------->回滚
// throw new Exception();//4、默认情况，非运行时异 常 事务---------------------->不回滚
}
/**
* 事务测试的内部方法 内部方法抛运行时异常不捕获 </br>
*
* 事务会对内外方法进行回滚操作
*/
@Override
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void insideMethod_01(){
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","2");
userMap.put("id","2");
userMap.put("userName","测试_02");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
// int value=1/0;//运行时异常
}
2、内部事务抛异常，外部事务回滚（一般来说，只要外部开启事务，内部方法无论是否开启事务如何配置，只要出现相应的运行时异常，内外事务都将进行回滚操作）
/**
* 测试事务的相关信息
* @throws Exception
*/
@Override
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void updateUser() throws Exception {
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","1");
userMap.put("userName","测试_01");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
insideMethod_01(); //1 、异常 不捕获 事务---------------------->回滚
// insideMethod_02(); //2、异常 捕获 事务---------------------->不回滚
// throw new RuntimeException(); //3、测试外部方法抛异常 事务---------------------->回滚
// throw new Exception();//4、默认情况，非运行时异 常 事务---------------------->不回滚
}
/**
* 事务测试的内部方法 内部方法抛运行时异常不捕获 </br>
*
* 事务会对内外方法进行回滚操作
*/
@Override
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void insideMethod_01(){
Map<String,String> userMap=new HashMap<String,String>();
userMap.put("id","2");
userMap.put("id","2");
userMap.put("userName","测试_02");
userMap.put("password","654321");
userDao.updateUserByID(userMap);
int value=1/0;//运行时异常
}
注:这里还有一点在实际开发中需要注意，如果外部方法调用了远程的接口，由于它们不在一个事务控制中，类似于分布式事务，这种情况远程事务是无法进行回滚操作的~