Spring2.0框架的事务处理

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

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>  

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



Xml代码 
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"> 



第二步:在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"/> 



第三步: 在接口或类的声明处 ,写一个@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.} 



注意的几点:

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

请看 "隔离级别"相关文章




















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

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





REQUIRED

业务方法需要在一个事务中运行,如果方法运行时,已处在一个事务中,那么就加入该事务,否则自己创建一个新的事务.这是spring默认的传播行为.



SUPPORTS

如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分,如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行.



MANDATORY

只能在一个已存在事务中执行,业务方法不能发起自己的事务,如果业务方法在没有事务的环境下调用,就抛异常



REQUIRES_NEW

业务方法总是会为自己发起一个新的事务,如果方法已运行在一个事务中,则原有事务被挂起,新的事务被创建,直到方法结束,新事务才结束,原先的事务才会恢复执行.



NOT_SUPPORTED

声明方法需要事务,如果方法没有关联到一个事务,容器不会为它开启事务.如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行.



NEVER

声明方法绝对不能在事务范围内执行,如果方法在某个事务范围内执行,容器就抛异常.只有没关联到事务,才正常执行.



NESTED

如果一个活动的事务存在,则运行在一个嵌套的事务中.如果没有活动的事务,则按REQUIRED属性执行.它使用了一个单独的事务, 这个事务拥有多个可以回滚的保证点.内部事务回滚不会对外部事务造成影响, 它只对DataSourceTransactionManager 事务管理器起效.