Spring-事务管理（Transaction）
1.事务介绍
事务（Transaction）：访问并能更新数据库中数据项的一个程序执行单元。
事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须要么全部完成，要么什么都不做，如果有一个失败了的话，那么事务就会回滚（RollBack）到最开始的状态，在企业级的应用程序中，事务管理是必不可少的，用来确保数据的完整性和一致性。
事务的特性（ACID）
- 原子性（Atomicity）：事务是一个原子操作，事务的原子性保证这些动作要么全部都做，要么什么都不做。
- 一致性（Consistency）：一旦事务完成（不论是成功还是失败），事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务由多少。也即是说，如果事务是并发多个，系统也必须入串行事务一样操作，其主要特征是保护性和不可变性，以转账案例为例子，假设有5个账户，每个账户余额是100，那么五个账户的总额是500，不管并发是多少，五个账户之间怎么频繁进行转账，总额都会保证是500，这就是保护性和一致性。
- 隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
- 持久性（Durability）：事务一旦完成，事务的结果必须被持久化到存储器中。
举个例子，也是后面实现过程中会一直用的例子：
1.Tom和Marry在某银行都有账户，且他们每个人的账户中都有1000元
2.Tom要向Marry汇款100元
那么这个汇款的执行可以分成下面几步：
1.检测Tom的账户里面有没有100块钱，如果有则允许汇款，如果没有则不允许汇款
2.Tom的银行账户，账户余额减去100元
3.Marry的银行账户，账户余额加上100元
那么问题来了，在2步和3步之间，可能会产生故障或者异常，最low的例子是2步完成之后，银行的服务器断电了。那么这个时候会不会出现Tom的银行账户少了100元，而Marry的银行账户却没有增加100元呢？
这个问题可以先说下：如果没有使用事务管理，这种情况确实是存在的。
那么如何模拟服务器断电这种异常呢：那就是在2步和3步之间加入一个异常（除零异常就可以）
Spring的事务管理的核心接口：
接着打开spring-tx包，可以继续查看org-springframework.transaction包
TransactionDefinition PlatformTransactionManager TransactionStatus是Spring事务管理的三个顶级接口，下面我们用图来解释下这三个接口之间的关系：
PlatformTransaction事务管理器
Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager，如上图所示Spring并不是直接管理事务，通过PlatformTransaction这个接口，Spring为各个平台如JDBC，Hibernate等提供对应的事务管理。也就是将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务实现。
进入到PlatformTransactionManager接口，查看源码：
- TransactionStatus getTransaction(TransactionDefinition definition) ，事务管理器通过TransactionDefinition，获得事务状态，从而管理事务
- void commit( TransactionStatus status)根据状态提交事务
- void rollback( TransactionStatus status)根据状态回滚事务
也就是说Spring事务管理是为不同的事务API提供统一的编程模型，具体的事务管理机制由对应的各个平台去实现：
有jdbc，orm平台：
TransactionDefinition基本事务属性定义
事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。
事务属性：传播行为，隔离规则，是否只读，事务超时，回滚规则。
TransactionDefinition接口定义的方法如下：
事务的传播行为和隔离级别的具体定义：
// Compiled from TransactionDefinition.java (version 1.6 : 50.0, no super bit) public abstract interface org.springframework.transaction.TransactionDefinition { // Field descriptor #4 I public static final int PROPAGATION_REQUIRED = 0; // Field descriptor #4 I public static final int PROPAGATION_SUPPORTS = 1; // Field descriptor #4 I public static final int PROPAGATION_MANDATORY = 2; // Field descriptor #4 I public static final int PROPAGATION_REQUIRES_NEW = 3; // Field descriptor #4 I public static final int PROPAGATION_NOT_SUPPORTED = 4; // Field descriptor #4 I public static final int PROPAGATION_NEVER = 5; // Field descriptor #4 I public static final int PROPAGATION_NESTED = 6; // Field descriptor #4 I public static final int ISOLATION_DEFAULT = -1; // Field descriptor #4 I public static final int ISOLATION_READ_UNCOMMITTED = 1; // Field descriptor #4 I public static final int ISOLATION_READ_COMMITTED = 2; // Field descriptor #4 I public static final int ISOLATION_REPEATABLE_READ = 4; // Field descriptor #4 I public static final int ISOLATION_SERIALIZABLE = 8;
具体解释下传播行为：传播行为指的是当事务被另一个事务调用时，必须指定事务如何传播的。可能这么说还是有点不清晰，那么可以看具体定义的几种传播行为的具体含义
- PROPAGATION_REQUIRED:required，必须，默认值，A如果有事务，B将使用该事务；如果A没有事务，B将创建一个新事务。
- PROPAGATION_SUPPORTS:supports，支持，A如果有事务，B将使用该事务；如果A没有事务，B将以非事务执行。
- PROPAGATION_MANDATORY：mandatory，强制，A如果有事务，B使用该事物；如果A没有事务，B将抛出异常。
- PROPAGATION_REQUIRES_NEW:requires_new，必须新的，A如果有事务，将A的事务挂起，B创建一个新的事务；如果A没有事务，B创建一个新的事务。
- PROPAGATION_NOT_SUPPORTED：not_supported,不支持，A如果有实物，将A的事务挂起，B以非事务执行；如果A没有事务，B以非事务执行。
- PROPAGATION_NEVER：never，从不，如果A有事务，B将抛出异常，如果A没有事务，B将以非事务执行。
- PROPAGATION_NESTED：nested，嵌套，A和B地产采用保存点机制，形成嵌套事务。
隔离级别：定义了一个事务可能受其他并发事务影响的程度
并发事务引起的问题：
- 脏读（dirty reads）：脏读数据发生在一个事务A读取了另一个事务B改写但是还未提交的数据时，如果事务B稍后将事务回滚了，那么A读取到的数据就是无效的，也即是事务A读取到了脏的数据。读脏数据
- 不可重复读（Nonrepeatable read）：不可重复读发生在一个事务A执行相同的查询两次或者两次以上，但是会得到不同的数据，这通常是因为在事务A读取数据的同时，另一个并发事务B在事务A的两次查询之间修改了数据。
- 幻读（Phantom read）：幻读和不可重复读类似，它发生在一个事务A，读取了几行数据，接着另一个事务B插入了一些数据，在随后的查询中，第一个事务A就会看到一些原本不在的记录。
不可重复的重点是“修改”，而幻读的重点是“新增”
在Spring的事务管理中，定义了如下隔离级别：
- ISOLATION_DEFAULT：使用后端数据库默认的隔离级别。
- ISOLATION_READ_UNCOMMITTED：最低隔离级别，允许读取修改但尚未提交的数据，脏读，不可重复读，幻读都有可能发生。
- ISOLATION_REPEATABLE_READ：对同一个字段的多次读取结果都是一致的，除非是事务自己修改了数据，可以阻止脏读和不可重复读，但是幻读依然可能存在。
- ISOLATION_READ_COMMITTED：允许事务读取修改且提交了的数据，可以防止脏读，但不可重复读和幻读依然可能存在。
- ISOLATION_SERIALIZABLE：最高隔离级别，脏读，不可重复读，幻读都可以避免，通常是完全锁定事务相关的数据表来实现，也是最慢的一种事务隔离级别。
只读
这是事务的第三个特性，是否将事务设置为只读。数据库可以利用事务的只读属性来进行一些优化。通过将事务设置成只读，你就可以给数据库一个机会，让它应用它认为合适的优化措施。
事务超时
为了使应用更好的运行，事务不能运行太长时间，因为事务可能涉及对后端数据库的锁定，所以很长时间的事务会不必要的占用数据库资源，事务超时就是事务的一个定时器，在特定的时间内如果事务没有执行完毕，那么就会自动回滚，而不是一直等待事务结束。
回滚规则
回滚规则定义了哪些异常会导致事务回滚而哪些异常不会导致回滚。默认情况下，事务遇到运行期异常时才会回滚，在遇到检查型异常时不会回滚。但是这些都是可以设置的。比如你可以设置检查型异常也进行事务回滚。
Spring编程式事务和声明式事务
编程式事务：所谓编程式事务就是指通过编码方式实现事务，允许用户在代码中精确定义事务的边界。即类似JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务，推荐使用TransactionTemplate。
声明式事务管理：管理建立在AOP上，其本质是对方法前后进行拦截，然后再目标方法开始之前创建或加入一个事务，在执行完目标方法之后根据执行情况提交或回滚事务。声明式事务最大的优点就是不需要通过编程的凡是管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需要在配置文件中做相关的事务规则声明（或者基于注解@Transaction的形式）。
实验
不用事务实现转账
数据库中有如下表：
有两个账户Tom和Marry，他们的初始账户余额都为10000.这时候我们进行如下业务：Tom向Marry转账100块，那么这在程序中可以分解为两个步骤：
①、Tom的账户余额1000减少100块，剩余900块
②、Marry的账户余额1000增加100块，变为1100块
上面两个步骤要么都执行成功，要么都不执行。我们通过TransactionTemplate编程式事务来控制：
编程式实现事务：
第一步：编写Dao层 AccountDao：
package com.fpc.Dao; public interface AccountDao { /* * 汇款 * @param outer 汇款人 * @param money 汇款金额 * */ public void out( String outer , int money ); /* * 收款 * @param inner 收款人 * @param money 收款金额 * */ public void in( String inner , int money ); }
第二步：编写Dao层接口的实现：AccountDaoImpl：
package com.fpc.DaoImpl; import org.aspectj.weaver.patterns.ThisOrTargetAnnotationPointcut; import org.springframework.jdbc.core.support.JdbcDaoSupport; import com.fpc.Dao.AccountDao; public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao { @Override public void out(String outer, int money) { // TODO 自动生成的方法存根 this.getJdbcTemplate().update("update account set money = money - ? where username = ?",money,outer); } @Override public void in(String inner, int money) { // TODO 自动生成的方法存根 this.getJdbcTemplate().update("update account set money = money + ? where username = ?",money,inner); } }
第三步：实现Service层 IAccountService
package com.fpc.Service; public interface IAccountService { /* * 转账 * @param outer 汇款人 * @param inner 收款人 * @param money 交易金额 * */ public void transfer( String outer , String inner , int money ); }
第四步：Service的具体实现 AccountServiceImpl
package com.fpc.ServiceImpl; import org.apache.shiro.authc.Account; import com.fpc.Dao.AccountDao; import com.fpc.Service.IAccountService; public class AccountServiceImpl implements IAccountService{ private AccountDao accounDao; public void setAccounDao(AccountDao accounDao) { this.accounDao = accounDao; } @Override public void transfer(String outer, String inner, int money) { // TODO 自动生成的方法存根 accounDao.out(outer, money); accounDao.in(inner, money); } }
第五步：配置applicationContext文件：
<bean id="accountDao" class="com.fpc.DaoImpl.AccountDaoImpl"> <property name="dataSource" ref="dataSource"></property> </bean> <bean id="accountService" class="com.fpc.ServiceImpl.AccountServiceImpl"> <property name="accounDao" ref="accountDao"></property> </bean>
第六步：编写单元测试类
package com.fpc.UnitTest; import org.apache.catalina.core.ApplicationContext; import org.junit.Test; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.apple.eawt.Application; import com.fpc.Service.IAccountService; import com.fpc.ServiceImpl.AccountServiceImpl; public class TransactionTest { @Test public void TestNoTransaction(){ ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); IAccountService accountService = (IAccountService) context.getBean("accountService"); //Tom 向 Marry转账100元 accountService.transfer("Tom", "Marry", 100); } }
运行查看数据库中的结果：
可见正常情况下，转账是可以成功的。
下面模拟异常情况：
那么这个时候我们执行单元测试程序，很显然会报“除零异常”
此时再去查看数据库中该表：
我们发现，Tom的账户中再次减少了100元，而Marray的账户中却没有增加100元。这在实际应用中肯定是不被允许的。
那么怎么去解决这个问题呢？肯定是引入事务管理
Dao层不变，我们在Service层注入TransactionTemplate模板，因为是用模板来管理事务，所以模板需要注入事务管理器。DatasourceTransactionManager，而事务管理器说到底层是JDBC在管理，所以我们需要在DatasourceTransactionManager中注入DataSource。
AccountServiceImpl：
package com.fpc.ServiceImpl; import org.apache.shiro.authc.Account; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.TransactionCallbackWithoutResult; import org.springframework.transaction.support.TransactionTemplate; import com.fpc.Dao.AccountDao; import com.fpc.Service.IAccountService; public class AccountServiceImpl implements IAccountService{ private AccountDao accounDao; private TransactionTemplate transactionTemplate; public void setAccounDao(AccountDao accounDao) { this.accounDao = accounDao; } public void setTransactionTemplate(TransactionTemplate transactionTemplate) { this.transactionTemplate = transactionTemplate; } @Override public void transfer(String outer, String inner, int money) { transactionTemplate.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus arg0) { // TODO 自动生成的方法存根 accounDao.out(outer, money); int i = 1/0; accounDao.in(inner, money); } }); }
更改配置文件：
<!-- 事务管理，transaction manager，user JtaTransactionManager for global tx --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <bean id="accountDao" class="com.fpc.DaoImpl.AccountDaoImpl"> <property name="dataSource" ref="dataSource"></property> </bean> <bean id="accountService" class="com.fpc.ServiceImpl.AccountServiceImpl"> <property name="accounDao" ref="accountDao"></property> <property name="transactionTemplate" ref="transactionTemplate"></property> </bean> <!-- 创建模板 --> <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"> <property name="transactionManager" ref="transactionManager"></property> </bean> <!-- 配置事物管理器，管理器需要事务，事务从Connection获得，连接从连接池获得 --> <!-- transactionManager配置在上面 -->
目前数据库中的数据为：
mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 800 | | 2 | Marry | 1100 | +----+----------+-------+
单元测试文件保持不变，分为两次测试，第一次操作没有“除零异常”，然后执行：数据能正常改变
mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 700 | | 2 | Marry | 1200 | +----+----------+-------+ 2 rows in set (0.00 sec)
第二次操作，加入“除零异常”：发现数据没有被更新，也就是出现异常后数据库进行了回滚。
mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 700 | | 2 | Marry | 1200 | +----+----------+-------+ 2 rows in set (0.00 sec)
声明式事务处理实现（AOP）
DAO层和Service不需要改变，主要是applicationContext.xml文件发生了变化。我们在applicationContext.xml中配置AOP自动生成代理，进行事务管理。
- 配置管理器
- 配置事务详情
- 配置AOP
<!-- 事务管理，transaction manager，user JtaTransactionManager for global tx --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <!-- 事务详情 ：在AOP筛选基础上，比如对ABC三个确定使用什么样的事物，例如AC读写，B只读等 <tx:attributes>用于配置事物详情（属性） <tx:method name=""/>详情具体配置 propagation:传播行为，REQUIRED：必须，REQUIRED_NEW：必须是新的，isolation：隔离级别 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/> </tx:attributes> </tx:advice> <!-- AOP切面编程，利用切入点表达式从目标类方法中，确定增强的连接器，从而获得切入点 --> <aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.fpc.ServiceImpl..*.*(..))"/> </aop:config> <bean id="accountDao" class="com.fpc.DaoImpl.AccountDaoImpl"> <property name="dataSource" ref="dataSource"></property> </bean> <bean id="accountService" class="com.fpc.ServiceImpl.AccountServiceImpl"> <property name="accounDao" ref="accountDao"></property> <!-- <property name="transactionTemplate" ref="transactionTemplate"></property> --> </bean> <!-- 创建模板 --> <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"> <property name="transactionManager" ref="transactionManager"></property> </bean> <!-- 配置事物管理器，管理器需要事务，事务从Connection获得，连接从连接池获得 --> <!-- transactionManager配置在上面 --> </beans>
AccountServiceImpl修改：
package com.fpc.ServiceImpl; import org.apache.shiro.authc.Account; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.TransactionCallbackWithoutResult; import org.springframework.transaction.support.TransactionTemplate; import com.fpc.Dao.AccountDao; import com.fpc.Service.IAccountService; @Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT) public class AccountServiceImpl implements IAccountService{ private AccountDao accounDao; public void setAccounDao(AccountDao accounDao) { this.accounDao = accounDao; } @Override public void transfer(String outer, String inner, int money) { accounDao.out(outer, money); int i = 1/0; accounDao.in(inner, money); } }
测试方法同上：两次测试，一次加“除零异常”，一次不加“除零异常”
运行结果如下：
mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 700 | | 2 | Marry | 1200 | +----+----------+-------+ 2 rows in set (0.00 sec) mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 600 | | 2 | Marry | 1300 | +----+----------+-------+ 2 rows in set (0.00 sec) mysql> select * from account; +----+----------+-------+ | id | username | money | +----+----------+-------+ | 1 | Tom | 600 | | 2 | Marry | 1300 | +----+----------+-------+ 2 rows in set (0.00 sec)
