Spring2.0注解实现事务管理

Spring2.0 框架的事务处理有两大类:

1 编码式事务 , 这个不说.

2 声明式事务 , 就说这个.

 

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

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

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

 

<!-- 事务测试DAO -->
<
bean
 
id
=
"go_TestPOAO"
 
class
=
"pic.dao.transaction_test.TestPOAOImpl"
 
parent
=
"go_POAOBase"
>
</
bean
>

<!-- 事务测试DAO 声明式事务管理 -->
<
bean
 
id
=
"go_TestPOAOProxy"
 
class
=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
>
        <
property
 
name
=
"proxyInterfaces"
>
            <
list
>
                <
value
>
pic.dao.transaction_test.TestPOAO
</
value
>
            </
list
>
        </
property
>
        <
property
 
name
=
"target"
 
ref
=
"go_TestPOAO"
/>
        <
property
 
name
=
"transactionManager"
 
ref
=
"transactionManager"
/>
        <
property
 
name
=
"transactionAttributes"
>
            <
props
>
                <
prop
 
key
=
"insert*"
>
PROPAGATION_REQUIRED
</
prop
>
            </
props
>
        </
property
>
</
bean
>

<!-- 事务测试DAO -->
<bean id="go_TestPOAO" class="pic.dao.transaction_test.TestPOAOImpl" parent="go_POAOBase"></bean>	
	
<!-- 事务测试DAO 声明式事务管理 -->
<bean id="go_TestPOAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
        <property name="proxyInterfaces">  
            <list>   
                <value>pic.dao.transaction_test.TestPOAO</value>  
            </list>  
        </property>  
        <property name="target" ref="go_TestPOAO"/>   
        <property name="transactionManager" ref="transactionManager"/>  
        <property name="transactionAttributes">  
            <props>  
                <prop key="insert*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
</bean> 

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

 

<
tx:advice
 
id
=
""
>
.....
</
tx:advice
>

<
aop:config
>
.....
</
aop:config
>

<tx:advice id="">
.....
</tx:advice>

<aop:config>
.....
</aop:config>

 

 

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

 

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

 

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

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

 

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

 

 

<!--JDBC
事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->
<bean id="transactionManager"
 
class
=
"org.springframework.jdbc.datasource.DataSourceTransactionManager"
>
        <property name="dataSource"
>
            <ref local="dataSource"
/>
        </property>
</bean>

<!-- 用
注解来实现事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager"
/>

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

 

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

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

 

@Transactional
public
 
class
 TestPOAOImpl 
extends
 POAOBase 
implements
 TestPOAO
{
    @Transactional
(isolation = Isolation.READ_COMMITTED)
    public
 
void
 test1()
    {
        String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)"
;
        execute(sql);

        sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)"
;
        execute(sql);

        int
 a = 
9
 / 
0
; 
//异常

        sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)"
;
        execute(sql);
        System.out.println("走完了"
);
    }
//execute() 方法略...
}

@Transactional
public class TestPOAOImpl extends POAOBase implements TestPOAO
{	
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void test1()
	{
		String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)";
		execute(sql);

		sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)";
		execute(sql);

		int a = 9 / 0; //异常

		sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)";
		execute(sql);
		System.out.println("走完了");
	}
//execute() 方法略...
}

 

注意的几点:

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 事务管理器起效.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

转载自：http://hypgr.iteye.com/blog/358740

评论

2 楼 elf8848 2010-04-13  

你应该 转自:
http://elf8848.iteye.com/blog/328095

1 楼 elf8848 2010-04-13  

引用

转载自：http://hypgr.iteye.com/blog/358740

哥们这文章我是原创, 是我写的