`

Spring事务管理

spring 
阅读更多

Spring是SSH中的管理员，负责管理其它框架，协调各个部分的工作。今天一起学习一下Spring的事务管理。Spring的事务管理分为声明式跟编程式。声明式就是在Spring的配置文件中进行相关配置；编程式就是用注解的方式写到代码里。下面先说声明式：

 

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。 下面一起看看三种声明式事务的具体配置：

 

声明式事务

 

公共配置

 

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 配置sessionFactory -->  
  2. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  3.     <property name="configLocation">  
  4.         <value>classpath:config/hibernate.cfg.xml</value>  
  5.     </property>  
  6.     <property name="packagesToScan">  
  7.         <list>  
  8.             <value>com.entity</value>  
  9.         </list>  
  10.     </property>  
  11. </bean>  
  12.   
  13. <!-- 配置事务管理器（声明式的事务） -->  
  14. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  15.     <property name="sessionFactory" ref="sessionFactory"></property>  
  16. </bean>  
  17.   
  18. <!-- 配置DAO -->   
  19. <bean id="userDao" class="com.dao.UserDaoImpl">  
  20.     <property name="sessionFactory" ref="sessionFactory"></property>  
  21. </bean>   
<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	<property name="configLocation">
		<value>classpath:config/hibernate.cfg.xml</value>
	</property>
	<property name="packagesToScan">
		<list>
			<value>com.entity</value>
		</list>
	</property>
</bean>

<!-- 配置事务管理器（声明式的事务） -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory"></property>
</bean>

<!-- 配置DAO --> 
<bean id="userDao" class="com.dao.UserDaoImpl">
	<property name="sessionFactory" ref="sessionFactory"></property>
</bean>



 

第一种，使用tx标签方式

 

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 第一种配置事务的方式 ，tx-->  
  2. <tx:advice id="txadvice" transaction-manager="transactionManager">  
  3.     <tx:attributes>  
  4.         <tx:method name="add*" propagation="REQUIRED" rollback-for="Exception" />  
  5.         <tx:method name="modify*" propagation="REQUIRED" rollback-for="Exception" />  
  6.         <tx:method name="del*" propagation="REQUIRED" rollback-for="Exception"/>  
  7.         <tx:method name="*" propagation="REQUIRED" read-only="true"/>  
  8.     </tx:attributes>  
  9. </tx:advice>  
  10.   
  11. <aop:config>  
  12.     <aop:pointcut id="daoMethod" expression="execution(* com.dao.*.*(..))"/>  
  13.     <aop:advisor pointcut-ref="daoMethod" advice-ref="txadvice"/>  
  14. </aop:config>   
<!-- 第一种配置事务的方式 ，tx-->
<tx:advice id="txadvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="add*" propagation="REQUIRED" rollback-for="Exception" />
		<tx:method name="modify*" propagation="REQUIRED" rollback-for="Exception" />
		<tx:method name="del*" propagation="REQUIRED" rollback-for="Exception"/>
		<tx:method name="*" propagation="REQUIRED" read-only="true"/>
	</tx:attributes>
</tx:advice>

<aop:config>
	<aop:pointcut id="daoMethod" expression="execution(* com.dao.*.*(..))"/>
	<aop:advisor pointcut-ref="daoMethod" advice-ref="txadvice"/>
</aop:config>

expression="execution(* com.dao.*.*(..))"
其中第一个*代表返回值，第二*代表dao下子包，第三个*代表方法名，“（..）”代表方法参数。

 


第二种，使用代理方式

 

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 第二种配置事务的方式 ，代理-->  
  2. <bean id="transactionProxy"  
  3.     class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">  
  4.     <property name="transactionManager" ref="transactionManager"></property>  
  5.     <property name="transactionAttributes">  
  6.         <props>  
  7.             <prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>  
  8.             <prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>  
  9.             <prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>  
  10.             <prop key="*">PROPAGATION_REQUIRED, readOnly</prop>  
  11.         </props>  
  12.     </property>  
  13. </bean>  
  14. <bean id="userDao" parent="transactionProxy">  
  15.     <property name="target">  
  16.         <!-- 用bean代替ref的方式-->  
  17.         <bean class="com.dao.UserDaoImpl">  
  18.             <property name="sessionFactory" ref="sessionFactory"></property>  
  19.         </bean>  
  20.     </property>  
  21. </bean>   
<!-- 第二种配置事务的方式 ，代理-->
<bean id="transactionProxy"
	class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"	abstract="true">
	<property name="transactionManager" ref="transactionManager"></property>
	<property name="transactionAttributes">
		<props>
			<prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
		</props>
	</property>
</bean>
<bean id="userDao" parent="transactionProxy">
	<property name="target">
		<!-- 用bean代替ref的方式-->
		<bean class="com.dao.UserDaoImpl">
			<property name="sessionFactory" ref="sessionFactory"></property>
		</bean>
	</property>
</bean>

将transactionProxy的abstract属性设置为"true"，然后将具体的Dao的parent属性设置为"transactionProxy"，可以精简代码。

 

第三种，使用拦截器

 

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 第三种配置事务的方式，拦截器 (不常用)-->  
  2. <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">  
  3.     <property name="transactionManager" ref="transactionManager"></property>  
  4.     <property name="transactionAttributes">  
  5.         <props>  
  6.             <prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>  
  7.             <prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>  
  8.             <prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>  
  9.             <prop key="*">PROPAGATION_REQUIRED, readOnly</prop>  
  10.         </props>  
  11.     </property>  
  12. </bean>  
  13. <bean id="proxyFactory" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
  14.     <property name="interceptorNames">  
  15.         <list>  
  16.             <value>transactionInterceptor</value>  
  17.         </list>  
  18.     </property>  
  19.     <property name="beanNames">  
  20.         <list>  
  21.             <value>*Dao</value>  
  22.         </list>  
  23.     </property>  
  24. </bean>   
<!-- 第三种配置事务的方式，拦截器 (不常用)-->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
	<property name="transactionManager" ref="transactionManager"></property>
	<property name="transactionAttributes">
		<props>
			<prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="modify*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="del*">PROPAGATION_REQUIRED, -Exception</prop>
			<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
		</props>
	</property>
</bean>
<bean id="proxyFactory" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
	<property name="interceptorNames">
		<list>
			<value>transactionInterceptor</value>
		</list>
	</property>
	<property name="beanNames">
		<list>
			<value>*Dao</value>
		</list>
	</property>
</bean>



 

Spring事务类型详解：

 

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

 

编程式事务

 

编程式即采用注解的方式，需要注意的是，使用注解的方式需要在Spring的配置文件中加入一句话：<context:annotation-config />，其作用是开启注解的方式。具体配置如下：

 

 

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!--开启注解方式-->  
  2. <context:annotation-config />  
  3.   
  4. <!-- 配置sessionFactory -->  
  5. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  6.     <property name="configLocation">  
  7.         <value>classpath:config/hibernate.cfg.xml</value>  
  8.     </property>  
  9.     <property name="packagesToScan">  
  10.         <list>  
  11.             <value>com.entity</value>  
  12.         </list>  
  13.     </property>  
  14. </bean>  
  15.   
  16. <!-- 配置事务管理器 -->  
  17. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  18.     <property name="sessionFactory" ref="sessionFactory"></property>  
  19. </bean>  
  20.   
  21. <!-- 第四种配置事务的方式，注解 -->  
  22. <tx:annotation-driven transaction-manager="transactionManager"/>   
<!--开启注解方式-->
<context:annotation-config />

<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	<property name="configLocation">
		<value>classpath:config/hibernate.cfg.xml</value>
	</property>
	<property name="packagesToScan">
		<list>
			<value>com.entity</value>
		</list>
	</property>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory"></property>
</bean>

<!-- 第四种配置事务的方式，注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

 

 

注解文件：

 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. package com.dao;  
  2.   
  3. import org.springframework.orm.hibernate3.HibernateTemplate;  
  4. import org.springframework.transaction.annotation.Propagation;  
  5. import org.springframework.transaction.annotation.Transactional;  
  6.   
  7. import com.entity.User;  
  8.   
  9. @Transactional  
  10. public class UserDaoImpl_BAK extends HibernateTemplate {  
  11.   
  12.     @Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")  
  13.     public void addUser(User user) throws Exception {  
  14.         this.save(user);  
  15.     }  
  16.   
  17.     @Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")  
  18.     public void modifyUser(User user) {  
  19.         this.update(user);  
  20.     }  
  21.   
  22.     @Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")  
  23.     public void delUser(String username) {  
  24.         this.delete(this.load(User.class, username));  
  25.     }  
  26.   
  27.     @Transactional(readOnly=true)  
  28.     public void selectUser() {  
  29.   
  30.     }  
  31.   
  32. }  
package com.dao;

import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.entity.User;

@Transactional
public class UserDaoImpl_BAK extends HibernateTemplate {

	@Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")
	public void addUser(User user) throws Exception {
		this.save(user);
	}

	@Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")
	public void modifyUser(User user) {
		this.update(user);
	}

	@Transactional(propagation=Propagation.REQUIRED,rollbackForClassName="Exception")
	public void delUser(String username) {
		this.delete(this.load(User.class, username));
	}

	@Transactional(readOnly=true)
	public void selectUser() {

	}

}


类头的@Transactional为默认事务配置，如方法没有自己的事务类型，则按默认事务，如有自己的配置，则按自己的配置。

 

 

以上四种配置方式最常用的还是第一、二种，第三种是比较老旧的方式，而注解的方式不太适合比较大的项目，用于简单的小项目还是很好的，其特点就是简单明了。每种方法都有每种方法的特点跟适用的环境，没有绝对的好与坏，只不过前两种在实际的工作当中用的更多一些。

 

好了，今天就到这里吧

分享到：
| Dubbo的使用学习
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring事务管理Demo

    Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...

    Spring事务管理开发必备jar包

    本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...

    spring事务管理

    ### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...

    spring 事务管理的理解

    Spring 框架是Java开发中...理解并熟练掌握Spring事务管理，对于提升应用程序的稳定性和可靠性至关重要。在实际开发中，结合声明式事务管理、事务传播行为、隔离级别和回滚规则，可以有效地确保数据的完整性和一致性。

    Spring事务管理.pdf

    Spring事务管理.pdf 1.资料 2.本地事务与分布式事务 3.编程式模型 4.宣告式模型

    Synchronized锁在Spring事务管理下线程不安全

    Synchronized锁在Spring事务管理下，导致线程不安全。

    Spring事务管理的jar包

    本篇将深入探讨Spring事务管理的核心概念、工作原理以及如何使用`spring-tx-3.2.0.RELEASE.jar`这个jar包。 首先，我们需要理解什么是事务。在数据库系统中，事务是一组操作，这些操作被视为一个整体，要么全部完成...

    Spring事务管理失效原因汇总

    标题“Spring事务管理失效原因汇总”指出了本文的核心内容是分析在使用Spring框架进行事务管理时可能遇到的问题及其原因。描述部分进一步说明了事务失效的后果往往不明显，容易在测试环节被忽略，但在生产环境中出现...

    spring事务管理5种方法

    本篇文章将深入探讨Spring事务管理的五种方法，旨在帮助开发者更好地理解和运用这一核心特性。 首先，我们来了解什么是事务。在数据库操作中，事务是一组逻辑操作，这些操作要么全部成功，要么全部失败，确保数据的...

    Spring事务管理4种方式

    本文将详细介绍Spring事务管理的四种方式：编程式事务管理、声明式事务管理、PlatformTransactionManager接口以及TransactionTemplate。 1. **编程式事务管理**：这是一种手动控制事务的方式，通过在代码中调用`...

    详细介绍Spring事务管理

    ### Spring事务管理详解 #### 一、Spring事务管理的重要性及必要性 在现代软件开发中，事务管理是一项至关重要的技术，特别是在涉及数据库操作时。事务能够确保一系列操作要么全部成功，要么全部失败，这对于保持...

    spring事务管理.rar

    Spring事务管理是Spring框架的核心特性之一，它提供了一种强大且灵活的方式来管理应用程序中的事务边界。在企业级Java应用中，事务处理是确保数据一致性、完整性和可靠性的关键部分。本篇文章将深入探讨Spring的事务...

    spring事务管理.doc

    总的来说，Spring事务管理提供了一种灵活、强大的方式来处理应用程序中的事务，无论是在简单还是复杂的事务场景下，都能有效保证数据的一致性和完整性。通过声明式事务管理，开发者可以将关注点从事务细节中解脱出来...

    Spring事务管理配置文件问题排查

    当出现像描述中那样的问题——SQL语句执行出错但事务未回滚时，我们需要深入理解Spring事务管理的配置和机制。以下是一些关键知识点： 1. **Spring事务管理类型**： - **编程式事务管理**：通过`...

    spring事务管理几种方式代码实例

    spring事务管理几种方式代码实例：涉及编程式事务，声明式事务之拦截器代理方式、AOP切面通知方式、AspectJ注解方式，通过不同方式实例代码展现，总结spring事务管理的一般规律，从宏观上加深理解spring事务管理特性...

    Spring事务管理和SpringJDBC思维导图

    在思维导图"Spring Transaction.twd"中，可能包含了Spring事务管理的各个概念和它们之间的关系，如事务的ACID属性（原子性、一致性、隔离性和持久性），事务管理器，以及声明式和编程式事务管理的实现方式。...

    Spring事务管理的方法

    ### Spring事务管理的方法 #### 一、引言 在企业级应用开发中，事务管理是一项至关重要的技术。Spring框架作为Java领域中一个非常流行的轻量级框架，为开发者提供了多种方式来实现事务管理，其中主要分为编程式...

    spring事务管理1

    Spring事务管理确保每个事务都是独立的，防止了脏读、不可重复读和幻读等问题。脏读是指事务T1读取了事务T2未提交的修改；不可重复读是指事务T1在不同时间读取同一数据时得到不同结果，因为T2在这期间做了修改；幻读...

Magicbox
Global site tag (gtag.js) - Google Analytics