spring的@Transactional注解详细用法

概述

事务管理对于企业应用来讲是相当重要的，即便出现异常状况，它也能够保证数据的一致性。
Spring Framework对事务管理提供了一致的抽象，其特色以下：

• 为不一样的事务API提供一致的编程模型，好比JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)
• 支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用
• 提供比其余事务API如JTA更简单的编程式事务管理API
• 与spring数据访问抽象的完美集成

事务管理方式

spring支持编程式事务管理和声明式事务管理两种方式。

编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。

声明式事务管理创建在AOP之上的。其本质是对方法先后进行拦截，而后在目标方法开始以前建立或者加入一个事务，在执行完目标方法以后根据执行状况提交或者回滚事务。声明式事务最大的优势就是不须要经过编程的方式管理事务，这样就不须要在业务逻辑代码中掺琐事务管理的代码，只需在配置文件中作相关的事务规则声明(或经过基于@Transactional注解的方式)，即可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就能够得到彻底的事务支持。和编程式事务相比，声明式事务惟一不足地方是，后者的最细粒度只能做用到方法级别，没法作到像编程式事务那样能够做用到代码块级别。可是即使有这样的需求，也存在不少变通的方法，好比，能够将须要进行事务管理的代码块独立为方法等等。

声明式事务管理也有两种经常使用的方式，一种是基于tx和aop名字空间的xml配置文件，另外一种就是基于@Transactional注解。显然基于注解的方式更简单易用，更清爽。

自动提交(AutoCommit)与链接关闭时的是否自动提交

自动提交

默认状况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，若是执行成功则隐式的提交事务，若是
执行失败则隐式的回滚事务。

对于正常的事务管理，是一组相关的操做处于一个事务之中，所以必须关闭数据库的自动提交模式。不过，这个咱们不用担忧，spring会将底层链接的自动提交特性设置为false。
org/springframework/jdbc/datasource/DataSourceTransactionManager.java

 1 // switch to manual commit if necessary. this is very expensive in some jdbc drivers,
 2 // so we don't want to do it unnecessarily (for example if we've explicitly
 3 // configured the connection pool to set it already).
 4 if (con.getautocommit()) {
 5     txobject.setmustrestoreautocommit(true);
 6     if (logger.isdebugenabled()) {
 7         logger.debug("switching jdbc connection [" + con + "] to manual commit");
 8     }
 9     con.setautocommit(false);
10 }

有些数据链接池提供了关闭事务自动提交的设置，最好在设置链接池时就将其关闭。但C3P0没有提供这一特性，只能依靠spring来设置。
由于JDBC规范规定，当链接对象创建时应该处于自动提交模式，这是跨DBMS的缺省值，若是须要,必须显式的关闭自动提交。C3P0遵照这一规范，让客户代码来显式的设置须要的提交模式。

链接关闭时的是否自动提交

当一个链接关闭时，若是有未提交的事务应该如何处理？JDBC规范没有说起，C3P0默认的策略是回滚任何未提交的事务。这是一个正确的策略，但JDBC驱动提供商之间对此问题并无达成一致。
C3P0的autoCommitOnClose属性默认是false,没有十分必要不要动它。或者能够显式的设置此属性为false，这样会更明确。

基于注解的声明式事务管理配置
spring-servlet.xml

1 <!-- transaction support-->
2 <!-- PlatformTransactionMnager -->
3 <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
4     <property name="dataSource" ref="dataSource" />
5 </bean>
6 <!-- enable transaction annotation support -->
7 <tx:annotation-driven transaction-manager="txManager" />

还要在spring-servlet.xml中添加tx名字空间

 1 ...
 2     xmlns:tx="http://www.springframework.org/schema/tx"
 3     xmlns:aop="http://www.springframework.org/schema/aop"
 4     xsi:schemaLocation="
 5     ...
 6  
 7 http://www.springframework.org/schema/tx
 8  
 9  
10 http://www.springframework.org/schema/tx/spring-tx.xsd
11  
12     ...

MyBatis自动参与到spring事务管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致便可，不然事务管理会不起做用。

另外须要下载依赖包aopalliance.jar放置到WEB-INF/lib目录下。不然spring初始化时会报异常
java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor

spring事务特性

spring全部的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口

1 public interface PlatformTransactionManager {
2  
3   TransactionStatus getTransaction(TransactionDefinition definition)
4     throws TransactionException;
5  
6   void commit(TransactionStatus status) throws TransactionException;
7  
8   void rollback(TransactionStatus status) throws TransactionException;
9 }

其中TransactionDefinition接口定义如下特性：

事务隔离级别

隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：

• TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，一般这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。
• TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务能够读取另外一个事务修改但尚未提交的数据。该级别不能防止脏读，不可重复读和幻读，所以不多使用该隔离级别。好比PostgreSQL实际上并无此级别。
• TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另外一个事务已经提交的数据。该级别能够防止脏读，这也是大多数状况下的推荐值。
• TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程当中能够屡次重复执行某个查询，而且每次返回的记录都相同。该级别能够防止脏读和不可重复读。
• TransactionDefinition.ISOLATION_SERIALIZABLE：全部的事务依次逐个执行，这样事务之间就彻底不可能产生干扰，也就是说，该级别能够防止脏读、不可重复读以及幻读。可是这将严重影响程序的性能。一般状况下也不会用到该级别。

事务传播行为

所谓事务的传播行为是指，若是在开始当前事务以前，一个事务上下文已经存在，此时有若干选项能够指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了以下几个表示传播行为的常量：

• TransactionDefinition.PROPAGATION_REQUIRED：若是当前存在事务，则加入该事务；若是当前没有事务，则建立一个新的事务。这是默认值。
• TransactionDefinition.PROPAGATION_REQUIRES_NEW：建立一个新的事务，若是当前存在事务，则把当前事务挂起。
• TransactionDefinition.PROPAGATION_SUPPORTS：若是当前存在事务，则加入该事务；若是当前没有事务，则以非事务的方式继续运行。
• TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，若是当前存在事务，则把当前事务挂起。
• TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，若是当前存在事务，则抛出异常。
• TransactionDefinition.PROPAGATION_MANDATORY：若是当前存在事务，则加入该事务；若是当前没有事务，则抛出异常。
• TransactionDefinition.PROPAGATION_NESTED：若是当前存在事务，则建立一个事务做为当前事务的嵌套事务来运行；若是当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

事务超时

所谓事务超时，就是指一个事务所容许执行的最长时间，若是超过该时间限制但事务尚未完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。

默认设置为底层事务系统的超时值，若是底层数据库事务系统没有设置超时值，那么就是none，没有超时限制。

事务只读属性

只读事务用于客户代码只读但不修改数据的情形，只读事务用于特定情景下的优化，好比使用Hibernate的时候。
默认为读写事务。

spring事务回滚规则

指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，而后依据规则决定是否回滚抛出异常的事务。

默认配置下，spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会致使事务回滚)，而抛出checked异常则不会致使事务回滚。
能够明确的配置在抛出那些异常时回滚事务，包括checked异常。也能够明肯定义那些异常抛出时不回滚事务。

还能够编程性的经过setRollbackOnly()方法来指示一个事务必须回滚，在调用完setRollbackOnly()后你所能执行的惟一操做就是回滚。

@Transactional注解

@Transactional属性

属性	类型	描述
value	String	可选的限定描述符，指定使用的事务管理器
propagation	enum: Propagation	可选的事务传播行为设置
isolation	enum: Isolation	可选的事务隔离级别设置
readOnly	boolean	读写或只读事务，默认读写
timeout	int (in seconds granularity)	事务超时时间设置
rollbackFor	Class对象数组，必须继承自Throwable	致使事务回滚的异常类数组
rollbackForClassName	类名数组，必须继承自Throwable	致使事务回滚的异常类名字数组
noRollbackFor	Class对象数组，必须继承自Throwable	不会致使事务回滚的异常类数组
noRollbackForClassName	类名数组，必须继承自Throwable	不会致使事务回滚的异常类名字数组

 

用法

@Transactional 能够做用于接口、接口方法、类以及类方法上。看成用于类上时，该类的全部 public 方法将都具备该类型的事务属性，同时，咱们也能够在方法级别使用该标注来覆盖类级别的定义。

虽然 @Transactional 注解能够做用于接口、接口方法、类以及类方法上，可是 Spring 建议不要在接口或者接口方法上使用该注解，由于这只有在使用基于接口的代理时它才会生效。另外， @Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。若是你在 protected、private 或者默承认见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常。

默认状况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其余方法并不会引发事务行为，即便被调用方法使用@Transactional注解进行修饰。

 1 @Transactional(readOnly = true)
 2 public class DefaultFooService implements FooService {
 3  
 4   public Foo getFoo(String fooName) {
 5     // do something
 6   }
 7  
 8   // these settings have precedence for this method
 9   //方法上注解属性会覆盖类注解上的相同属性
10   @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
11   public void updateFoo(Foo foo) {
12     // do something
13   }
14 }

 

注意的几点:
1 @Transactional 只能被应用到public方法上, 对于其它非public的方法,若是标记了@Transactional也不会报错,但方法没有事务功能.

2用 spring 事务管理器,由spring来负责数据库的打开,提交,回滚.默认遇到运行期例外(throw new RuntimeException("注释");)会回滚，即遇到不受检查（unchecked）的例外时回滚；而遇到须要捕获的例外(throw new Exception("注释");)不会回滚,即遇到受检查的例外（就是非运行时抛出的异常，编译器会检查到的异常叫受检查例外或说受检查异常）时，需咱们指定方式来让事务回滚 要想全部异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .若是让unchecked例外不回滚： @Transactional(notRollbackFor=RunTimeException.class)
以下:
@Transactional(rollbackFor=Exception.class) //指定回滚,遇到异常Exception时回滚
public void methodName() {
throw new Exception("注释");

}
@Transactional(noRollbackFor=Exception.class)//指定不回滚,遇到运行期例外(throw new RuntimeException("注释");)会回滚
public ItimDaoImpl getItemDaoImpl() {
throw new RuntimeException("注释");
}

三、@Transactional 注解应该只被应用到 public 可见度的方法上。 若是你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 可是这个被注解的方法将不会展现已配置的事务设置。

四、@Transactional 注解能够被应用于接口定义和接口方法、类定义和类的 public 方法上。然而，请注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据，可以被能够识别 @Transactional 注解和上述的配置适当的具备事务行为的beans所使用。上面的例子中，其实正是 <tx:annotation-driven/>元素的出现 开启 了事务行为。

五、Spring团队的建议是你在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。你固然能够在接口上使用 @Transactional 注解，可是这将只能当你设置了基于接口的代理时它才生效。由于注解是 不能继承 的，这就意味着若是你正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，并且对象也将不会被事务代理所包装（将被确认为严重的）。因 此，请接受Spring团队的建议而且在具体的类上使用 @Transactional 注解。

 

在实际开发中，对于一组数据库操做特别是增删改操做，为了保证原子性，经过须要用事务来控制，要么所有成功，要么所有失败。Spring中能够经过注解@Transaction

经常使用的方法以下：

 

@Transactional
public void testTransaction(User user) {
int rowNum = userMapper.insertUser(user);
List<User> userList = userMapper.selectAllUsers();
}
这里将两个操做insert和select看成原子操做，若是在testTransaction方法中有异常，则回滚。（注意：这个事务是MySQL层控制，回滚的操做也是MySQL控制的）。

须要注意的问题：

（1）尽量将MySQL执行语句往方法体后面靠：

 

@Transactional
public void testTransaction(User user) {
int rowNum = userMapper.insertUser(user);
doSomething(); // 这个doSomthing 可能耗时较长
List<User> userList = userMapper.selectAllUsers();
}
若是能够移动的话，能够将doSomething()可能耗时较长，移动到int rowNum=userMapper.insertUser(user)的前面，即：

@Transactional
public void testTransaction(User user) {
doSomething(); // 这个doSomthing 可能耗时较长
int rowNum = userMapper.insertUser(user);
List<User> userList = userMapper.selectAllUsers();
}
由于，MySQL事务的commit语句是在第一次执行MySQL相关语句开始，一直到方法的结束。

（2）设置事务的超时时间（若是不设置默认是-1是无限长）

 

@Transactional(timeout = 5)
public void testTransaction(User user) throws InterruptedException {
Thread.sleep(2000);
List<User> userList = userMapper.selectAllUsers(); // 耗时：1s
int rowNum = userMapper.insertUser(user); // 耗时 1s
Thread.sleep(3000);
}
加入另外两个MySQL相关的操做耗时都是1s，则上述事务是不会报超时异常。

timeout的计算的事务超时 = 最后一个MySQL语句耗时 + 以及最后一个MySQL以前的全部耗时。所以，上述耗时为2s+1s+1s=4s，没有超过5s，所以不会报事务超时异常，这个须要特别注意，若是想了解具体原理，能够查看源码，或者看该文档：http://jinnianshilongnian.iteye.com/blog/1986023

 

还有特别好的文章：：：：：：：：：：：：：：：：：：：https://blog.csdn.net/fanxb92/article/details/81296005