spring事务管理

理论篇：

什么是事务？

举个简单点的例子，张三和李四之间相互转账，假设张三通过支付宝转给李四400元，首先会修改张三的账户余额，把张三的总金额减去400，然后再找到李四的账户，为李四的账户增加400元；我们说这才是一件完整的事情，很简单的这件事情就是张三给李四转账，这个事情的任务就是李四要收到张三的400元，如果张三因为转账途中断网断电了，那就说明这个事务不完整；所以我们要控制这个事务要么一起成功，一起失败；

事务的四大特性：

原子性：所谓原子是指我这个单位已经是最小不可分割的了，一个事务应该是具有原子性的，他们应该是要么一起改变状态，要么都不会改变；

一致性：一致性是指事务在改变前后的数据完整性一定要保持一致，这里假设张三有2000元转给李四400元后还剩下1600，李四假设也有2000元，接收到了张三的400元后，变成了2400，他们的总数加起来还是4000；中间没有丢失任何金额和数据；

隔离性：隔离性指多个用户并发访问数据库时，一个用户的事务不能被其他用户的事务所干扰，多个并发事务之间的数据要隔离起来；这里解释起来就比较复杂了，这里说张三正在向李四转账400元的途中，又有一个叫王五的也在给李四转账，那么我们说一个事务不能被另外一个事务所影响，他们之间必须要有一个先后顺序；我们的数据库都有自己定义的一套隔离级别，具体实现后面再说；

持久性：持久性是指一个事务一旦提交了，它对数据库的改变就是永久性的，即使数据库忽然断了，那么也要保证不会对其事务有任何影响；

Spring事务管理的的主要三个接口：

PlatformTransactionManager 事务管理器

TransactionDefinition 事务定义信息（隔离，传播，超时，只读)

TransactionStatus 事务具体运行状态

PlatformTransactionManager会根据不同的ORM框架来选择不同的实现类，下面列举几个主要实现

TransactionDefinition：

主要来控制我们事务的隔离级别，如果不控制隔离级别就会发生脏读，不可重复读和幻读的问题；

脏读：一个事务读取了另一个事务改写但未提交的数据，如果这些数据被回滚，则读到的数据是无效的；

 不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同；

幻读：一个事务读取了几行记录后，另一个事务插入一些记录，幻读就发生了。再后来的查询中，第一个事务 就会发现有些原来没有的记录；

实战篇：

第一种编程式事务管理，所谓编程式是指，我们会事先配置好事务的模板，但是当我们需要事务的时候会采用编程的时候去执行事务；

我们先创建一个数据库表结构，模拟上面的转账;

[sql]  view plain  copy

 

1. CREATE TABLE `account` (  
2.   `id` int(11) NOT NULL AUTO_INCREMENT,  
3.   `name` varchar(20) NOT NULL,  
4.   `money` double DEFAULT NULL,  
5.   PRIMARY KEY (`id`)  
6. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;  
7. INSERT INTO `account` VALUES ('1', '张三', '1000');  
8. INSERT INTO `account` VALUES ('2', '李四', '1000');  
9. INSERT INTO `account` VALUES ('3', '王五', '1000');  

接着再配置一下spring容器，再里面声明一下事务：

[java]  view plain  copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.      xmlns:context="http://www.springframework.org/schema/context"  
5.      xmlns:aop="http://www.springframework.org/schema/aop"  
6.      xmlns:tx="http://www.springframework.org/schema/tx"  
7.      xmlns:task="http://www.springframework.org/schema/task"  
8.      xsi:schemaLocation="http://www.springframework.org/schema/beans  
9.          http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
10.          http://www.springframework.org/schema/context  
11.          http://www.springframework.org/schema/context/spring-context-3.1.xsd  
12.          http://www.springframework.org/schema/aop  
13.          http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  
14.          http://www.springframework.org/schema/tx  
15.          http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
16.          http://www.springframework.org/schema/task  
17.          http://www.springframework.org/schema/task/spring-task-3.1.xsd">  
18.   
19.     <!-- 引入外部的属性文件 -->  
20.     <context:property-placeholder location="classpath:jdbc.properties"/>  
21.       
22.     <!-- 配置c3p0连接池 -->  
23.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
24.         <property name="driverClass" value="${jdbc.driverClass}" />  
25.         <property name="jdbcUrl" value="${jdbc.url}" />  
26.         <property name="user" value="${jdbc.username}" />  
27.         <property name="password" value="${jdbc.password}" />  
28.     </bean>  
29.       
30.     <!-- 配置业务层类 -->  
31.     <bean id="accountService" class="com.zs.spring.demo1.AccountServiceImpl">  
32.         <property name="accountDao" ref="accountDao" />  
33.         <!-- 注入事务管理的模板 -->  
34.         <property name="transactionTemplate" ref="transactionTemplate" />  
35.     </bean>  
36.       
37.     <!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->  
38.     <bean id="accountDao" class="com.zs.spring.demo1.AccountDaoImpl">  
39.         <property name="dataSource" ref="dataSource" />  
40.     </bean>  
41.       
42.     <!-- 配置DAO类(未简化) -->  
43.     <!-- <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
44.         <property name="dataSource" ref="dataSource" />  
45.     </bean>  
46.     <bean id="accountDao" class="com.zs.spring.demo1.AccountDaoImpl">  
47.         <property name="jdbcTemplate" ref="jdbcTemplate" />  
48.     </bean> -->  
49.       
50.     <!-- ==================================1.编程式的事务管理=============================================== -->  
51.     <!-- 配置事务管理器 -->  
52.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
53.         <property name="dataSource" ref="dataSource" />  
54.     </bean>  
55.       
56.     <!-- 配置事务管理的模板:Spring为了简化事务管理的代码而提供的类 -->  
57.     <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
58.         <property name="transactionManager" ref="transactionManager"/>  
59.     </bean>  
60.       
61. </beans>  

声明DAO：

[java]  view plain  copy

 

1. public interface AccountDao {  
2.   
3.     /** 
4.      * @param out   :转出账号 
5.      * @param money :转账金额 
6.      */  
7.     public void outMoney(String out,Double money);  
8.       
9.     /** 
10.      *  
11.      * @param in    :转入账号 
12.      * @param money :转账金额 
13.      */  
14.     public void inMoney(String in,Double money);  
15. }  

[java]  view plain  copy

 

1. /** 
2.      * @param out   :转出账号 
3.      * @param money :转账金额 
4.      */  
5.     @Override  
6.     public void outMoney(String out, Double money) {  
7.         String sql = "update account set money = money-? where name = ?";  
8.         this.getJdbcTemplate().update(sql, money, out);  
9.     }  
10.   
11.     /** 
12.      * @param in    :转入账号 
13.      * @param money :转账金额 
14.      */  
15.     @Override  
16.     public void inMoney(String in, Double money) {  
17.         String sql = "update account set money = money+? where name = ?";  
18.         this.getJdbcTemplate().update(sql,money,in);  
19.     }  

声明service

[java]  view plain  copy

 

1. public interface AccountService {  
2.   
3.     /** 
4.      * @param out   :转出账号 
5.      * @param in    :转入账号 
6.      * @param money :转账金额 
7.      */  
8.     public void transfer(String out,String in,Double money);  
9. }  

[java]  view plain  copy

 

1. public class AccountServiceImpl implements AccountService {  
2.       
3.     //注入转账的DAO  
4.     private AccountDao accountDao;  
5.       
6.       
7.     //注入事务管理的模板  
8.     private TransactionTemplate transactionTemplate;  
9.   
10.     /** 
11.      * @param out   :转出账号 
12.      * @param in    :转入账号 
13.      * @param money :转账金额 
14.      */  
15.     @Override  
16.     public void transfer(final String out, final String in, final Double money) {  
17.         /*accountDao.outMoney(out, money); 
18.         //int i = 1/0; 
19.         accountDao.inMoney(in, money);*/  
20.           
21.           
22.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
23.   
24.             @Override  
25.             protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {  
26.                 accountDao.outMoney(out, money);  
27.                 //int i = 1/0;  
28.                 accountDao.inMoney(in, money);  
29.             }  
30.         });  
31.     }  
32.   
33.     public void setAccountDao(AccountDao accountDao) {  
34.         this.accountDao = accountDao;  
35.     }  
36.   
37.     public void setTransactionTemplate(TransactionTemplate transactionTemplate) {  
38.         this.transactionTemplate = transactionTemplate;  
39.     }  
40.   
41. }  

测试：

[java]  view plain  copy

 

1. @RunWith(SpringJUnit4ClassRunner.class)  
2. @ContextConfiguration("classpath:applicationContext1.xml")  
3. public class TransactionTest {  
4.   
5.     @Resource(name="accountService")  
6.     private AccountService accountService;  
7.       
8.     @Test  
9.     public void demo1(){  
10.         accountService.transfer("张三", "李四", 200d);  
11.     }  
12. }  

使用XML配置声明式的事务管理(原始方式)：

[html]  view plain  copy

 

1. <!-- 配置事务管理器 -->  
2.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
3.         <property name="dataSource" ref="dataSource" />  
4.     </bean>  
5.       
6.     <!-- 配置业务层的代理 -->  
7.     <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
8.         <!-- 配置目标对象 -->  
9.         <property name="target" ref="accountService" />  
10.         <!-- 注入事务管理器 -->  
11.         <property name="transactionManager" ref="transactionManager"></property>  
12.         <!-- 注入事务的属性 -->  
13.         <property name="transactionAttributes">  
14.             <props>  
15.                 <!--   
16.                     prop的格式:  
17.                         * PROPAGATION   :事务的传播行为  
18.                         * ISOTATION     :事务的隔离级别  
19.                         * readOnly      :只读  
20.                         * -EXCEPTION    :发生哪些异常回滚事务  
21.                         * +EXCEPTION    :发生哪些异常不回滚事务  
22.                  -->  
23.                 <prop key="transfer">PROPAGATION_REQUIRED</prop>  
24.                 <!-- <prop key="transfer">PROPAGATION_REQUIRED,readOnly</prop> -->  
25.                 <!-- <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop> -->  
26.             </props>  
27.         </property>  
28.     </bean>  

使用XML配置声明式的事务管理,基于tx/aop：

[html]  view plain  copy

 

1. <!-- ==================================3.使用XML配置声明式的事务管理,基于tx/aop=============================================== -->  
2.       
3.     <!-- 配置事务管理器 -->  
4.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
5.         <property name="dataSource" ref="dataSource" />  
6.     </bean>  
7.       
8.     <!-- 配置事务的通知 -->  
9.     <tx:advice id="txAdvice" transaction-manager="transactionManager">  
10.         <tx:attributes>  
11.             <!--   
12.                 propagation :事务传播行为  
13.                 isolation   :事务的隔离级别  
14.                 read-only   :只读  
15.                 rollback-for:发生哪些异常回滚  
16.                 no-rollback-for :发生哪些异常不回滚  
17.                 timeout     :过期信息  
18.              -->  
19.             <tx:method name="transfer" propagation="REQUIRED"/>  
20.         </tx:attributes>  
21.     </tx:advice>  
22.       
23.     <!-- 配置切面 -->  
24.     <aop:config>  
25.         <!-- 配置切入点 -->  
26.         <aop:pointcut expression="execution(* com.zs.spring.demo3.AccountService+.*(..))" id="pointcut1"/>  
27.         <!-- 配置切面 -->  
28.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>  
29.     </aop:config>  

使用注解配置声明式事务

[html]  view plain  copy

 

1. <!-- ==================================4.使用注解配置声明式事务============================================ -->  
2.   
3.     <!-- 配置事务管理器 -->  
4.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
5.         <property name="dataSource" ref="dataSource" />  
6.     </bean>  
7.       
8.     <!-- 开启注解事务 -->  
9.     <tx:annotation-driven transaction-manager="transactionManager"/>  

[java]  view plain  copy

 

1. /** 
2.  *  
3.  * @author admin 
4.  * 
5.  * 
6.  *@Transactional中的的属性 
7.  *propagation   :事务的传播行为 
8.  *isolation     :事务的隔离级别 
9.  *readOnly      :只读 
10.  *rollbackFor   :发生哪些异常回滚 
11.  *noRollbackFor :发生哪些异常不回滚 
12.  *rollbackForClassName 根据异常类名回滚 
13.  */  
14. @Transactional  
15. public class AccountServiceImpl implements AccountService {  
16.       
17.     //注入转账的DAO  
18.     private AccountDao accountDao;  
19.       
20.   
21.     /** 
22.      * @param out   :转出账号 
23.      * @param in    :转入账号 
24.      * @param money :转账金额 
25.      */  
26.     @Override  
27.     public void transfer( String out, String in, Double money) {  
28.         accountDao.outMoney(out, money);  
29.         //int i = 1/0;  
30.         accountDao.inMoney(in, money);  
31.           
32.     }  
33.   
34.     public void setAccountDao(AccountDao accountDao) {  
35.         this.accountDao = accountDao;  
36.     }  
37.   
38. }