Spring之事务管理
1.1 事务的基础简介
1.1.1 事务的例子
理解事务之前，先讲一个你日常生活中最常干的事：取钱。
比如你去ATM机取1000块钱，大体有两个步骤：首先输入密码金额，银行卡扣掉1000元钱；然后ATM出1000元钱。这两个步骤必须是要么都执行要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是ATM却出了1000块，那么银行将损失1000元。所以，如果一个步骤成功另一个步骤失败对双方都不是好事，如果不管哪一个步骤失败了以后，整个取钱过程都能回滚，也就是完全取消所有操作的话，这对双方都是极好的。
1.1.2 事务解决什么？
事务就是用来解决类似问题的。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。
在企业级应用程序开发中，事务管理必不可少的技术，用来确保数据的完整性和一致性。
1.1.3 事务的特性
事务有四个特性：ACID
原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。
1.1.4 Spring管理何时需要解决数据的完整性和一致性
Java包含两种异常：checked异常和unchecked异常。
checked和unchecked异常之间的区别是：
Checked异常必须被显式地捕获try-catch-finally,而unchecked异常则可以不必捕获或抛出。
Checked异常继承Java.lang.Exception类。
Unchecked异常继承自java.lang.RuntimeException类。
spring事务处理
throw new RuntimeException(“xxxxxxxxxxxx”); 默认事务回滚
throw new Exception(“xxxxxxxxxxxx”); 默认事务不回滚
SqlException继承Exception ,是Exception的子类
Exception是所有异常对象的基类
而SqlException只在执行SQL方法时才有
所有这个时候需要引入Spring来解决手动配置事务回滚操作。
使用Spring框架提供一致的事务管理方式，给程序带来的优点：
1、提供简单易用的编程式事务管理API。（编程式）不建议使用
2、支持声明式事务管理。（配置式，结合aop来配置）
3、便于Spring整合各种数据访问技术。
1.2 核心接口
Spring事务管理的实现有许多细节，如果对整个接口框架有个大体了解会非常有利于我们理解事务，下面通过讲解Spring的事务接口来了解Spring实现事务的具体策略。
Spring事务管理涉及的接口的联系如下：
1.3 事务管理器
Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。
Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了。
此接口的源码内容如下：
| public interface PlatformTransactionManager{ // 由TransactionDefinition得到TransactionStatus对象 TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; // 提交 void commit(TransactionStatus status)throws TransactionException; // 回滚 void rollback(TransactionStatus status) throws TransactionException; } |
从这里可知具体的具体的事务管理机制对Spring来说是透明的，它并不关心那些，那些是对应各个平台需要关心的，所以Spring事务管理的一个优点就是为不同的事务API提供一致的编程模型，如JTA、JDBC、Hibernate、JPA。
1.3.0.1 JDBC事务
如果应用程序中直接使用JDBC来进行持久化，DataSourceTransactionManager会为你处理事务边界。为了使用DataSourceTransactionManager，你需要使用如下的XML将其装配到应用程序的上下文定义中：
| <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> bean> |
实际上，DataSourceTransactionManager是通过调用java.sql.Connection来管理事务，而后者是通过DataSource获取到的。通过调用连接的commit()方法来提交事务，同样，事务失败则通过调用rollback()方法进行回滚。
1.3.0.2 Hibernate事务
如果应用程序的持久化是通过Hibernate实习的，那么你需要使用HibernateTransactionManager。对于Hibernate3，需要在Spring上下文定义中添加如下的
| <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> bean> |
sessionFactory属性需要装配一个Hibernate的session工厂，HibernateTransactionManager的实现细节是它将事务管理的职责委托给org.hibernate.Transaction对象，而后者是从Hibernate Session中获取到的。当事务成功完成时，HibernateTransactionManager将会调用Transaction对象的commit()方法，反之，将会调用rollback()方法。
1.3.0.3 Java持久化API事务（JPA）
Hibernate多年来一直是事实上的Java持久化标准，但是现在Java持久化API作为真正的Java持久化标准进入大家的视野。如果你计划使用JPA的话，那你需要使用Spring的JpaTransactionManager来处理事务。你需要在Spring中这样配置JpaTransactionManager：
| <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> bean> |
JpaTransactionManager只需要装配一个JPA实体管理工厂（javax.persistence.EntityManagerFactory接口的任意实现）。JpaTransactionManager将与由工厂所产生的JPA EntityManager合作来构建事务。
1.3.0.4 Java原生API事务
如果你没有使用以上所述的事务管理，或者是跨越了多个事务管理源（比如两个或者是多个不同的数据源），你就需要使用JtaTransactionManager：
| <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"> <property name="transactionManagerName" value="java:/TransactionManager" /> bean> |
JtaTransactionManager将事务管理的责任委托给javax.transaction.UserTransaction和javax.transaction.TransactionManager对象，其中事务成功完成通过UserTransaction.commit()方法提交，事务失败通过UserTransaction.rollback()方法回滚。
1.4 基本事务属性的定义
上面讲到的事务管理器接口PlatformTransactionManager通过getTransaction(TransactionDefinition definition)方法来得到事务，这个方法里面的参数是TransactionDefinition类，这个类就定义了一些基本的事务属性。
那么什么是事务属性呢？事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。事务属性包含了5个方面，如图所示：
而TransactionDefinition接口源码内容如下：
public interface TransactionDefinition {
int getPropagationBehavior(); // 返回事务的传播行为
int getIsolationLevel(); // 返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
int getTimeout(); // 返回事务必须在多少秒内完成
boolean isReadOnly(); // 事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的
}
我们可以发现TransactionDefinition正好用来定义事务属性
1.4.1 传播行为
事务的第一个方面是传播行为（propagation behavior）。当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring定义了七种传播行为：
| 传播行为 |
含义 |
| [PROPAGATION_ ] REQUIRED |
表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务 |
| [PROPAGATION_ ] SUPPORTS |
表示当前方法不需要事务上下文（如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器） |
| [PROPAGATION_ ] MANDATORY |
如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 |
| [PROPAGATION_ ] REQUIRES_NEW |
总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。（REQUIRES_NEW,需要使用 JtaTransactionManager作为事务管理器。） |
| [PROPAGATION_ ] NOT_SUPPORTED |
总是非事务地执行，并挂起任何存在的事务。（NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。） |
| [PROPAGATION_ ] NEVER |
总是非事务地执行，如果存在一个活动事务，则抛出异常。 |
| [PROPAGATION_ ] NESTED |
如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition. REQUIRED 属性执行（这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。） |
传播行为是必须设置的属性，其他的都可以忽略。
1.4.2 隔离级别
事务的第二个维度就是隔离级别（isolation level）。隔离级别定义了一个事务可能受其他并发事务影响的程度。
1、并发事务引起的问题
在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务。并发虽然是必须的，但可能会导致一下的问题。
脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务改写但尚未提交的数据时。如果改写在稍后被回滚了，那么第一个事务获取的数据就是无效的。
不可重复读（Nonrepeatable read）——不可重复读发生在一个事务执行相同的查询两次或两次以上，但是每次都得到不同的数据时。这通常是因为另一个并发事务在两次查询期间进行了更新。
幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录。
不可重复读与幻读的区别
不可重复读的重点是修改:
同样的条件, 你读取过的数据, 再次读取出来发现值不一样了
| 例如：在事务1中，Mary 读取了自己的工资为1000,操作并没有完成 con1 = getConnection(); select salary from employee empId ="Mary"; 在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务. con2 = getConnection(); update employee set salary = 2000; con2.commit(); 在事务1中，Mary 再次读取自己的工资时，工资变为了2000 //con1 select salary from employee empId ="Mary"; 在一个事务中前后两次读取的结果并不一致，导致了不可重复读。
|
幻读的重点在于新增或者删除：
同样的条件, 第1次和第2次读出来的记录数不一样
| 例如：目前工资为1000的员工有10人。事务1,读取所有工资为1000的员工。 con1 = getConnection(); Select * from employee where salary =1000; 共读取10条记录 这时另一个事务向employee表插入了一条员工记录，工资也为1000 con2 = getConnection(); Insert into employee(empId,salary) values("Lili",1000); con2.commit(); 事务1再次读取所有工资为1000的员工 //con1 select * from employee where salary =1000; 共读取到了11条记录，这就产生了幻像读。
|
从总的结果来看, 似乎不可重复读和幻读都表现为两次读取的结果不一致。但如果你从控制的角度来看, 两者的区别就比较大。
对于前者, 只需要锁住满足条件的记录。
对于后者, 要锁住满足条件及其相近的记录。
根据隔离成都分为不同的五种隔离级别：
| 隔离级别 |
含义 |
| READ_UNCOMMITTED |
最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读 |
| READ_COMMITTED |
允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生，该级别适用于大多数系统。 |
| REPEATABLE_READ |
对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生 |
| SERIALIZABLE |
最高的隔离级别，完全服从ACID的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的 |
| DEFAULT |
使用后端数据库默认的隔离级别 |
1.4.3 只读
事务的第三个特性是它是否为只读事务。如果事务只对后端的数据库进行该操作，数据库可以利用事务的只读特性来进行一些特定的优化。通过将事务设置为只读，你就可以给数据库一个机会，让它应用它认为合适的优化措施。
1.4.4 事务超时
为了使应用程序很好地运行，事务不能运行太长的时间。因为事务可能涉及对后端数据库的锁定，所以长时间的事务会不必要的占用数据库资源。事务超时就是事务的一个定时器，在特定时间内事务如果没有执行完毕，那么就会自动回滚，而不是一直等待其结束。
1.4.5 回滚规则
事务五边形的最后一个方面是一组规则，这些规则定义了哪些异常会导致事务回滚而哪些不会。默认情况下，事务只有遇到运行期异常时才会回滚，而在遇到检查型异常时不会回滚（这一行为与EJB的回滚行为是一致的）
但是你可以声明事务在遇到特定的检查型异常时像遇到运行期异常那样回滚。同样，你还可以声明事务遇到特定的异常不回滚，即使这些异常是运行期异常。
1.5 事务状态
上面讲到的调用PlatformTransactionManager接口的getTransaction()的方法得到的是TransactionStatus接口的一个实现，这个接口的内容如下：
| public interface TransactionStatus{ boolean isNewTransaction(); // 是否是新的事物 boolean hasSavepoint(); // 是否有恢复点 void setRollbackOnly(); // 设置为只回滚 boolean isRollbackOnly(); // 是否为只回滚 boolean isCompleted; // 是否已完成} |
可以发现这个接口描述的是一些处理事务提供简单的控制事务执行和查询事务状态的方法，在回滚或提交的时候需要应用对应的事务状态。
2 事务管理应用
2.1 编程式事务(可以不掌握) 不建议使用
2.1.1 编程式和声明式事务的区别
Spring提供了对编程式事务和声明式事务的支持，编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。
简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。
2.1.2 如何实现编程式事务？
Spring提供两种方式的编程式事务管理，分别是：使用TransactionTemplate和直接使用PlatformTransactionManager。
2.1.2.1 使用TransactionTemplate
采用TransactionTemplate和采用其他Spring模板，如JdbcTempalte和HibernateTemplate是一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate是线程安全的。
| TransactionTemplate tt = new TransactionTemplate(); // 新建一个TransactionTemplate Object result = tt.execute( new TransactionCallback(){ public Object doTransaction(TransactionStatus status){ // 数据库操作 updateOperation(); return resultOfUpdateOperation(); } }); // 执行execute方法进行事务管理 |
使用TransactionCallback()可以返回一个值。如果使用TransactionCallbackWithoutResult则没有返回值。
2.1.2.2 使用PlatformTransactionManager
| //定义一个某个框架平台的TransactionManager，如JDBC、Hibernate DataSourceTransactionManager tm= new DataSourceTransactionManager(); tm.setDataSource(this.getJdbcTemplate().getDataSource()); // 设置数据源 DefaultTransactionDefinition transDef = new DefaultTransactionDefinition(); // 定义事务属性 transDef.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED); // 设置传播行为属性 TransactionStatus status = tm.getTransaction(transDef); // 获得事务状态 try { // 数据库操作 ... ... tm.commit(status);// 提交 } catch (Exception e) { tm.rollback(status);// 回滚 } |
2.2 声明式事务
spring支持事务的原理：
Spring 的声明式事务管理在底层是建立在 AOP 的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。
声明式事务最大的优点:
就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是 AOP 的用武之地。Spring 开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。
和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。
详细如下图：
2.2.1 基于 命名空间的声明式事务管理
Spring 2.x 引入了
现在企业里面很多常用此法配置。
实现步骤：
2.2.1.1 配置数据源
|
<context:property-placeholder location="classpath:resource/*.properties" />
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> <property name="driverClassName" value="${jdbc.driver}" /> <property name="maxActive" value="10" /> <property name="minIdle" value="5" /> bean> |
2.2.1.2 事务管理器
|
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" /> bean> |
2.2.1.3 使用tx命名空间配置AOP方面通知
|
<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes>
<tx:method name="save*" propagation="REQUIRED" /> <tx:method name="insert*" propagation="REQUIRED" /> <tx:method name="add*" propagation="REQUIRED" /> <tx:method name="create*" propagation="REQUIRED" /> <tx:method name="delete*" propagation="REQUIRED" /> <tx:method name="update*" propagation="REQUIRED" /> <tx:method name="find*" propagation="SUPPORTS" read-only="true" /> <tx:method name="select*" propagation="SUPPORTS" read-only="true" /> <tx:method name="get*" propagation="SUPPORTS" read-only="true" /> tx:attributes> tx:advice> |
2.2.1.4 将方面通知指定到切入点
|
<aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.eduask.it.service.*.*(..))" /> aop:config> |
或者：
| <aop:pointcut id="bankPointcut" expression="execution(* com.eduask.it.service.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="bankPointcut"/>
|
这样代码层不用做任何处理就在service添加了事务管理。
注意：由于使用了切点表达式，我们就不需要针对每一个业务类创建一个代理对象了。另外，如果配置的事务管理器 Bean 的名字取值为“transactionManager”，则我们可以省略
2.2.2 基于全注解
2.2.2.1 配置数据源
与上雷同
2.2.2.2 配置事务管理器
与上面雷同
2.2.2.3 开启事务注解扫描
| <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/> |
2.2.2.4 在DAO上需加上@Transactional注解
| @Transactional @Component("userDao") public class UserDaoImpl implements UserDao { public List<User> listUsers() {
} } |
2.3 事务案例演示：
2.3.1 注解版案例
需求：批量插入用户
编写映射接口方法
| void inserUser(UserVO user); |
编写映射sql方法
| <insert id="inserUser" parameterType="com.eduask.it.vo.UserVO">
insert into user_zht (id, username) values (user_seq.nextval,#{username}) insert> |
编写服务层调用mapper对象
| public void inserUser(){ UserVO user1 = new UserVO(); user1.setUsername("zhangsan111"); dao.inserUser(user1); //模拟异常 String str = null; str.length(); UserVO user2 = new UserVO(); user2.setUsername("zhangsan2222"); dao.inserUser(user2); } |
在spring中配置事务器以及开始事务注解扫描
|
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" /> bean>
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/> |
在要事务控制的对象添加注解
2.3.2 tx配置案例
略。。。。。
2.3.3 回滚机制演示
在注解版案例中模拟非运行时异常
| Class.forName("dd"); |
Tx配置时添加
| <tx:method name="insert*" propagation="REQUIRED" rollback-for="java.lang.ClassNotFoundException"/> |
注解版时添加如下
| @Transactional(rollbackFor=ClassNotFoundException.class) |