Spring中JDBC声明式事务管理

方式一：使用org.springframework.transaction.interceptor.TransactionProxyFactoryBean
applicationContext.xml

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.   xmlns="http://www.springframework.org/schema/beans"  
4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">  
6.   <!-- JDBC模板 -->  
7.   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
8.     <property name="dataSource">  
9.       <ref local="dataSource"/>  
10.     </property>  
11.   </bean>  
12.   <!-- 数据源 -->  
13.   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
14.     <property name="driverClassName">  
15.       <value>org.gjt.mm.mysql.Driver</value>  
16.     </property>  
17.     <property name="url">  
18.       <value>jdbc:mysql://localhost:3306/test</value>  
19.     </property>  
20.     <property name="username">  
21.       <value>root</value>  
22.     </property>  
23.     <property name="password">  
24.       <value>root</value>  
25.     </property>  
26.   </bean>  
27.   <!--事务模板 -->  
28.   <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
29.     <property name="transactionManager">  
30.       <ref local="transactionManager"/>  
31.     </property>  
32.   </bean>  
33.   <!-- jdbc事务管理器 -->  
34.   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
35.     <property name="dataSource">  
36.       <ref local="dataSource"/>  
37.     </property>  
38.   </bean>  
39.   <bean id="testDao" class="com.spring.jdbc.JdbcTemplateTest2">  
40.     <property name="jdbcTemplate">  
41.       <ref local="jdbcTemplate"/>  
42.     </property>  
43.   </bean>  
44.     
45.   <bean id="testDaoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
46.     <property name="transactionManager">  
47.       <ref local="transactionManager"/>  
48.     </property>  
49.     <property name="target">  
50.       <ref local="testDao"/>  
51.     </property>  
52.     <property name="transactionAttributes">  
53.       <props>  
54.         <prop key="*">PROPAGATION_REQUIRED</prop>  
55.       </props>  
56.     </property>  
57.   </bean>  
58. </beans>  

测试代码：

[java]  view plain copy

1. public class JdbcTemplateTest2 {  
2.   private JdbcTemplate jdbcTemplate = null;  
3.   
4.   public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
5.     this.jdbcTemplate = jdbcTemplate;  
6.   }  
7.     
8.   public void updateUser(){  
9.       jdbcTemplate.execute("insert into test(name,age) values('Tom',20)");  
10.       jdbcTemplate.execute("insert into test(name,ages) values('Tom',20)");  
11.   }  
12.     
13.   public static void main(String[] args) {  
14.     ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  
15.     JdbcTemplateTest2 test =  (JdbcTemplateTest2)ctx.getBean("testDaoProxy");  
16.     test.updateUser();  
17.   }  
18. }  

当updateUser中发生异常的时候，则两条记录都不会被插入。此方式实现的缺点，针对每个需要进行事务管理的bean都需要定义
TransactionProxyFactoryBean，造成较多的冗余代码。


方式二：
采用TransactionInterceptor通知和BeanNameAutoProxyCreator自动代理
applicationContext.xml

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.   xmlns="http://www.springframework.org/schema/beans"  
4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">  
6.   <!-- JDBC模板 -->  
7.   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
8.     <property name="dataSource">  
9.       <ref local="dataSource"/>  
10.     </property>  
11.   </bean>  
12.   <!-- 数据源 -->  
13.   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
14.     <property name="driverClassName">  
15.       <value>org.gjt.mm.mysql.Driver</value>  
16.     </property>  
17.     <property name="url">  
18.       <value>jdbc:mysql://localhost:3306/test</value>  
19.     </property>  
20.     <property name="username">  
21.       <value>root</value>  
22.     </property>  
23.     <property name="password">  
24.       <value>root</value>  
25.     </property>  
26.   </bean>  
27.   <!--事务模板 -->  
28.   <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
29.     <property name="transactionManager">  
30.       <ref local="transactionManager"/>  
31.     </property>  
32.   </bean>  
33.   <!-- jdbc事务管理器 -->  
34.   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
35.     <property name="dataSource">  
36.       <ref local="dataSource"/>  
37.     </property>  
38.   </bean>  
39.     
40.     
41.     
42.   <bean id="testDao" class="com.spring.jdbc.JdbcTemplateTest2">  
43.     <property name="jdbcTemplate">  
44.       <ref local="jdbcTemplate"/>  
45.     </property>  
46.   </bean>  
47.   <!-- 方式二 (自动代理)-->    
48.   <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">  
49.     <property name="transactionManager">  
50.       <ref local="transactionManager"/>  
51.     </property>  
52.     <property name="transactionAttributes">  
53.       <props>  
54.         <prop key="*">PROPAGATION_REQUIRED</prop>  
55.       </props>  
56.     </property>  
57.   </bean>  
58.     
59.     <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
60.     <property name="beanNames">  
61.       <list>  
62.         <!-- 需要管理事务的bean,可以定义若干个 -->  
63.         <value>testDao</value>  
64.       </list>  
65.     </property>  
66.     <property name="interceptorNames">  
67.       <list>  
68.         <!-- 事务通知，可以定义多个通知-->  
69.         <value>transactionIntercep</value>  
70.       </list>  
71.     </property>  
72.   </bean>  
73.     
74. </beans>  

测试代码：

[java]  view plain copy

1. public class JdbcTemplateTest2 {  
2.   private JdbcTemplate jdbcTemplate = null;  
3.   
4.   public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
5.     this.jdbcTemplate = jdbcTemplate;  
6.   }  
7.     
8.   public void updateUser(){  
9.       jdbcTemplate.execute("insert into test(name,age) values('Tom',20)");  
10.       jdbcTemplate.execute("insert into test(name,ages) values('Tom',20)");  
11.   }  
12.     
13.   public static void main(String[] args) {  
14.     ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  
15.     JdbcTemplateTest2 test =  (JdbcTemplateTest2)ctx.getBean("testDao");  
16.     test.updateUser();  
17.   }  
18. }  

声明式事务又有三种实现方法:

1 (第一种) 最早的方法,用TransactionProxyFactoryBean,他是一个有AOP代理功能的FactoryBean.他返回的对象有事务.

还要在spring的配置文件XML中配置,比较麻烦,不详细说.

Xml代码

1. <!-- 事务测试DAO -->  
2. <bean id="go_TestPOAO" class="pic.dao.transaction_test.TestPOAOImpl"parent="go_POAOBase"></bean>      
3.        
4. <!-- 事务测试DAO 声明式事务管理 -->  
5. <bean id="go_TestPOAOProxy"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">     
6.         <property name="proxyInterfaces">     
7.             <list>      
8.                 <value>pic.dao.transaction_test.TestPOAO</value>     
9.             </list>     
10.         </property>     
11.         <property name="target" ref="go_TestPOAO"/>      
12.         <property name="transactionManager" ref="transactionManager"/>     
13.         <property name="transactionAttributes">     
14.             <props>     
15.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>     
16.             </props>     
17.         </property>     
18. </bean>   

[xml]  view plain copy

1. <!-- 事务测试DAO -->  
2. <bean id="go_TestPOAO" class="pic.dao.transaction_test.TestPOAOImpl" parent="go_POAOBase"></bean>   
3.    
4. <!-- 事务测试DAO 声明式事务管理 -->  
5. <bean id="go_TestPOAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">    
6.         <property name="proxyInterfaces">    
7.             <list>     
8.                 <value>pic.dao.transaction_test.TestPOAO</value>    
9.             </list>    
10.         </property>    
11.         <property name="target" ref="go_TestPOAO"/>     
12.         <property name="transactionManager" ref="transactionManager"/>    
13.         <property name="transactionAttributes">    
14.             <props>    
15.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>    
16.             </props>    
17.         </property>    
18. </bean>  

2 (第二种) 使用<tx:>来实现声明式事务 ,也要在spring的配置文件XML中配置,比较麻烦,不详细说.

Xml代码

1. <tx:advice id="">  
2. .....   
3. </tx:advice>  
4.   
5. <aop:config>  
6. .....   
7. </aop:config>  

[xml]  view plain copy

1. <tx:advice id="">  
2. .....  
3. </tx:advice>  
4.   
5. <aop:config>  
6. .....  
7. </aop:config>  

 

 

3 (第三种) 这个方法方便,使用注解来实现声明式事务, 下面详细说说这个方法:

 

第一步:引入<tx:>命名空间 ,在spring的配置文件中修改, beans根元素里多了三行,如下

Xml代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:tx="http://www.springframework.org/schema/tx"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.      http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
8.      http://www.springframework.org/schema/tx   
9.      http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  

[xml]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.  xmlns="http://www.springframework.org/schema/beans"  
4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:tx="http://www.springframework.org/schema/tx"  
6.  xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.  http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
8.     http://www.springframework.org/schema/tx   
9.     http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  

 

第二步:在spring的配置文件中修改,将所有具有@Transactional 注解的bean自动配置为声明式事务支持

Java代码

1. <!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->     
2. <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">   
3.          <property name="dataSource">   
4.              <ref local="dataSource"/>   
5.          </property>   
6. </bean>      
7.            
8. <!-- 用注解来实现事务管理 -->   
9. <tx:annotation-driven transaction-manager="transactionManager"/>  

[java]  view plain copy

1. <!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->   
2. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
3.   <property name="dataSource">  
4.    <ref local="dataSource"/>  
5.   </property>  
6. </bean>   
7.     
8. <!-- 用注解来实现事务管理 -->  
9. <tx:annotation-driven transaction-manager="transactionManager"/>  

 

第三步: 在接口或类的声明处 ,写一个@Transactional. 要是只的接口上写, 接口的实现类就会继承下来.

接口的实现类的具体方法,还可以覆盖类声明处的设置.

Java代码

1. @Transactional  
2. public class TestPOAOImpl extends POAOBase implements TestPOAO   
3. {      
4.     @Transactional(isolation = Isolation.READ_COMMITTED)   
5.     public void test1()   
6.      {   
7.          String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)";   
8.          execute(sql);   
9.   
10.          sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)";   
11.          execute(sql);   
12.   
13.         int a = 9 / 0; //异常   
14.   
15.          sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)";   
16.          execute(sql);   
17.          System.out.println("走完了");   
18.      }   
19. //execute() 方法略...   
20. }  

[java]  view plain copy

1. @Transactional  
2. public class TestPOAOImpl extends POAOBase implements TestPOAO  
3. {   
4.     @Transactional(isolation = Isolation.READ_COMMITTED)  
5.     public void test1()  
6.  {  
7.   String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)";  
8.   execute(sql);  
9.   
10.   sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)";  
11.   execute(sql);  
12.   
13.   int a = 9 / 0; //异常  
14.   
15.   sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)";  
16.   execute(sql);  
17.   System.out.println("走完了");  
18.  }  
19. //execute() 方法略...  
20. }  

 

注意的几点:

1 @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

 

2 默认情况下,一个有事务方法, 遇到RuntiomeException 时会回滚 . 遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .

 

 

 

@Transactional 的所有可选属性如下:

 

属性	类型	默认值	说明
propagation	Propagation枚举	REQUIRED	事务传播属性 (下有说明)
isolation	isolation枚举	DEFAULT	事务隔离级别 (另有说明)
readOnly	boolean	false	是否只读
timeout	int	-1	超时(秒)
rollbackFor	Class[]	{}	需要回滚的异常类
rollbackForClassName	String[]	{}	需要回滚的异常类名
noRollbackFor	Class[]	{}	不需要回滚的异常类
noRollbackForClassName	String[]	{}	不需要回滚的异常类名

 

 

事务的隔离级别 有如下可选:

可以去看spring源码 : org.springframework.transaction.annotation.Isolation

DEFAULT采用数据库默认隔离级别

READ_UNCOMMITTED

READ_COMMITTED

REPEATABLE_READ

SERIALIZABLE

数据库提供了四种事务隔离级别, 不同的隔离级别采用不同的锁类开来实现.

在四种隔离级别中, Serializable的级别最高, Read Uncommited级别最低.

大多数数据库的默认隔离级别为: Read Commited,如Sql Server , Oracle.

少数数据库默认的隔离级别为Repeatable Read, 如MySQL InnoDB存储引擎

即使是最低的级别,也不会出现 第一类 丢失 更新问题 .

• Read Uncommited :读未提交数据( 会出现脏读,不可重复读,幻读 ,避免了 第一类丢失 更新 )
  
• Read Commited :读已提交的数据(会出现不可重复读,幻读)
  
• Repeatable Read :可重复读(会出现幻读)
  
• Serializable :串行化

 

丢失 更新 : 
当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，会发生丢失更新问题。每个事务都不知道其它事务的存在。最后的更新将重写由其它事务所做的更新，这将导致数据丢失。 　　
例:
事务A和事务B同时修改某行的值，
1.事务A将数值改为1并提交
2.事务B将数值改为2并提交。
这时数据的值为2，事务A所做的更新将会丢失。 
解决办法：对行加锁，只允许并发一个更新事务。

 

脏读: 一个事务读到另一个事务未提交的更新数据

例:

1.Mary的原工资为1000, 财务人员将Mary的工资改为了8000(但未提交事务)         
2.Mary读取自己的工资 ,发现自己的工资变为了8000，欢天喜地！
3.而财务发现操作有误，回滚了事务,Mary的工资又变为了1000, 像这样,Mary记取的工资数8000是一个脏数据。

 

不可重复读: 在同一个事务中,多次读取同一数据,返回的结果有所不同. 换句话说就是,后续读取可以读到另一个事务已提交的更新数据. 相反"可重复读"在同一事务多次读取数据时,能够保证所读数据一样,也就是后续读取不能读到另一事务已提交的更新数据.

例:

1.在事务1中，Mary 读取了自己的工资为1000,操作并没有完成
2.在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
3.在事务1中，Mary 再次读取自己的工资时，工资变为了2000
解决办法：如果只有在修改事务完全提交之后才可以读取数据，则可以避免该问题。

 

幻读: 一个事务读取到另一个事务已提交的insert数据.

例:

第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时 (此时第一事务还未提交) ，第二个事务向表中插入一行新数据。这时第一个事务再去读取表时,发现表中还有没有修改的数据行，就好象发生了幻觉一样。

 

事务的传播属性 ,有如下可选

可以去看spring源码 : org.springframework.transaction.annotation.Propagation

 

REQUIRED	业务方法需要在一个事务中运行,如果方法运行时,已处在一个事务中,那么就加入该事务,否则自己创建一个新的事务.这是spring默认的传播行为.
SUPPORTS	如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分,如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行.
MANDATORY	只能在一个已存在事务中执行,业务方法不能发起自己的事务,如果业务方法在没有事务的环境下调用,就抛异常
REQUIRES_NEW	业务方法总是会为自己发起一个新的事务,如果方法已运行在一个事务中,则原有事务被挂起,新的事务被创建,直到方法结束,新事务才结束,原先的事务才会恢复执行.
NOT_SUPPORTED	声明方法需要事务,如果方法没有关联到一个事务,容器不会为它开启事务.如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行.
NEVER	声明方法绝对不能在事务范围内执行,如果方法在某个事务范围内执行,容器就抛异常.只有没关联到事务,才正常执行.
NESTED	如果一个活动的事务存在,则运行在一个嵌套的事务中.如果没有活动的事务,则按REQUIRED属性执行.它使用了一个单独的事务, 这个事务拥有多个可以回滚的保证点.内部事务回滚不会对外部事务造成影响, 它只对DataSourceTransactionManager 事务管理器起效.