`
lzkyo
  • 浏览: 468129 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

spring 事务管理

Spring配置管理BeanHibernateMySQL 
阅读更多

声明式的事务管理（Declarative transaction management）：
<1>事务配置方式：

Java代码 复制代码
  1. <!-- dataSource for MySQL -->   
  2. <bean id="dataSource"  
  3.         class="org.apache.commons.dbcp.BasicDataSource"  
  4.         destroy-method="close">   
  5.         <property name="driverClassName"  
  6.             value="com.mysql.jdbc.Driver" />   
  7.         <property name="url"  
  8.             value="jdbc:mysql://localhost:3306/springapp" />   
  9.         <property name="username" value="root" />   
  10.         <property name="password" value="root" />   
  11. </bean>     
<!-- dataSource for MySQL -->
<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver" />
		<property name="url"
			value="jdbc:mysql://localhost:3306/springapp" />
		<property name="username" value="root" />
		<property name="password" value="root" />
</bean>


Java代码 复制代码
  1. <!-- Hibernate SessionFactory for MySQL -->   
  2. <bean id="sessionFactory"  
  3.     class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
  4.         <property name="dataSource" ref="dataSource" />   
  5.         <property name="mappingDirectoryLocations">   
  6.             <list>   
  7.                 <value>classpath:/</value>   
  8.             </list>   
  9.         </property>   
  10.         <property name="hibernateProperties">   
  11.             <props>   
  12.                 <prop key="hibernate.dialect">   
  13.                     org.hibernate.dialect.MySQLDialect   
  14.                 </prop>   
  15.                 <prop key="hibernate.show_sql">true</prop>   
  16.                 <prop key="hibernate.jdbc.fetch_size">10</prop>   
  17.                 <prop key="hibernate.jdbc.batch_size">50</prop>   
  18.             </props>   
  19.         </property>   
  20. </bean>  
<!-- Hibernate SessionFactory for MySQL -->
<bean id="sessionFactory"
	class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath:/</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.jdbc.fetch_size">10</prop>
				<prop key="hibernate.jdbc.batch_size">50</prop>
			</props>
		</property>
</bean>


Java代码 复制代码
  1. <!—define transactionManager -->   
  2. <bean id="transactionManager"  
  3.   class="org.springframework.orm.hibernate3.HibernateTransactionManager">   
  4.   <property name="sessionFactory">   
  5.    <ref local="sessionFactory" />   
  6.   </property>   
  7. </bean>  
<!—define transactionManager -->
<bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
</bean>


Java代码 复制代码
  1. <!—business layer -->   
  2. <bean id="userManageService"  
  3.   class="com.test.service.impl.userManageServiceImpl">   
  4.   <property name="userLoginDao">   
  5.    <ref bean="userLoginDao" />   
  6.   </property>   
  7. …   
  8. </bean>  
<!—business layer -->
<bean id="userManageService"
  class="com.test.service.impl.userManageServiceImpl">
  <property name="userLoginDao">
   <ref bean="userLoginDao" />
  </property>
…
</bean>



第一种：使用TransactionProxyFactoryBean，配置声明式事务的方法如下。
(1)表比较少的情况:

Java代码 复制代码
  1. <bean id="userManagerServiceProxy"  
  2.   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">   
  3.   <!-- 配置事务管理器 -->   
  4.   <property name="transactionManager">   
  5.    <ref bean="transactionManager" />   
  6.   </property>   
  7.   <!-- 此属性指定目标类本身是否是代理的对象，如果目标类没有实现任何类，就设为true代表自己 -->   
  8.   <property name="proxyTargetClass">   
  9.    <value>false</value>   
  10.   </property>   
  11.   <property name="proxyInterfaces">   
  12.    <value> com.test.service.userManageService</value>   
  13.   </property>   
  14.   <!-- 目标bean -->   
  15.   <property name="target">   
  16.    <ref bean="userManageService"/>   
  17.   </property>   
  18.   <!-- 配置事务属性 -->   
  19. <property name="transactionAttributes">   
  20.    <props>   
  21. <prop key="delete*">PROPAGATION_REQUIRED</prop>   
  22. <prop key="add*">PROPAGATION_REQUIRED</prop>   
  23. <prop key="update*">PROPAGATION_REQUIRED</prop>   
  24. <prop key="save*">PROPAGATION_REQUIRED</prop>   
  25. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>   
  26. </props>   
  27. </property>   
  28. </bean>  
<bean id="userManagerServiceProxy"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <!-- 配置事务管理器 -->
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <!-- 此属性指定目标类本身是否是代理的对象，如果目标类没有实现任何类，就设为true代表自己 -->
  <property name="proxyTargetClass">
   <value>false</value>
  </property>
  <property name="proxyInterfaces">
   <value> com.test.service.userManageService</value>
  </property>
  <!-- 目标bean -->
  <property name="target">
   <ref bean="userManageService"/>
  </property>
  <!-- 配置事务属性 -->
<property name="transactionAttributes">
   <props>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>


(2)利用继承的思想简化配置,适合相对比较多的模块时使用。

Java代码 复制代码
  1.  <bean id="transactionBase"  
  2.   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
  3.   lazy-init="true" abstract="true">   
  4.   <!-- 配置事务管理器 -->   
  5.   <property name="transactionManager">   
  6.    <ref bean="transactionManager" />   
  7.   </property>   
  8.   <!-- 配置事务属性 -->   
  9.   <property name="transactionAttributes">   
  10.    <props>   
  11. <prop key="delete*">PROPAGATION_REQUIRED</prop>   
  12. <prop key="add*">PROPAGATION_REQUIRED</prop>   
  13. <prop key="update*">PROPAGATION_REQUIRED</prop>   
  14. <prop key="save*">PROPAGATION_REQUIRED</prop>   
  15. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>   
  16. </props>   
  17. </property>   
  18. </bean>  
 <bean id="transactionBase"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
  lazy-init="true" abstract="true">
  <!-- 配置事务管理器 -->
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <!-- 配置事务属性 -->
  <property name="transactionAttributes">
   <props>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>


而具体的模块可以简单的这样配置。只要指明它的parent（父类）就可以了。父类一般把abstract="true"，因为在容器加载的时候不需要初始化，等到用的时候再有它的子类调用的时候，再去初始化。

Java代码 复制代码
  1. <bean id="userManageServiceProxy" parent="transactionBase" >   
  2.   <property name="target">   
  3.   <ref bean="userManageService"/>   
  4.   </property>   
  5. </bean>  
<bean id="userManageServiceProxy" parent="transactionBase" >
  <property name="target">
  <ref bean="userManageService"/>
  </property>
</bean>


第二种：自动创建事务代理的方式。主要利用BeanNameAutoProxyCreator自动创建事务代理

Java代码 复制代码
  1.   <!--利用了拦截器的原理。-->   
  2.   <bean id="transactionInterceptor"  
  3.   class="org.springframework.transaction.interceptor.TransactionInterceptor">   
  4.   <property name="transactionManager">    
  5.   <ref bean="transactionManager" />   
  6.   </property>   
  7.   <!-- 配置事务属性 -->   
  8.   <property name="transactionAttributes">   
  9.    <props>   
  10. <prop key="delete*">PROPAGATION_REQUIRED</prop>   
  11. <prop key="add*">PROPAGATION_REQUIRED</prop>   
  12. <prop key="update*">PROPAGATION_REQUIRED</prop>   
  13. <prop key="save*">PROPAGATION_REQUIRED</prop>   
  14. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>   
  15. </props>   
  16. </property>   
  17. </bean>   
  18. <bean id="serviceProxy "  
  19.   class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
  20.  <property name="beanNames">   
  21. <list>   
  22. <value>userManageService</value>   
  23. </list>   
  24. <!--或者直接用 <value>*Service</value>-->   
  25. </property>   
  26.   <property name="interceptorNames">   
  27.    <list>   
  28. <value>transactionInterceptor</value>   
  29. </list>   
  30. </property>   
  31. </bean>  
  <!--利用了拦截器的原理。-->
  <bean id="transactionInterceptor"
  class="org.springframework.transaction.interceptor.TransactionInterceptor">
  <property name="transactionManager"> 
  <ref bean="transactionManager" />
  </property>
  <!-- 配置事务属性 -->
  <property name="transactionAttributes">
   <props>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="serviceProxy "
  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
 <property name="beanNames">
<list>
<value>userManageService</value>
</list>
<!--或者直接用 <value>*Service</value>-->
</property>
  <property name="interceptorNames">
   <list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>


<2>事务中异常

Java代码 复制代码
  1. <!-- 配置事务属性 -->   
  2. <property name="transactionAttributes">   
  3.    <props>   
  4. <!--指定了 "PROPAGATION_REQUIRED"，表示在当前的事务中执行操作，如果事务不存在就建立一个新的-->   
  5. <prop key="delete*">PROPAGATION_REQUIRED,-ProgramException</prop>   
  6. <prop key="add*">PROPAGATION_REQUIRED,-ProgramException</prop>   
  7. <prop key="update*">PROPAGATION_REQUIRED, -ProgramException</prop>   
  8. <prop key="save*">PROPAGATION_REQUIRED, -ProgramException</prop>   
  9. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>   
  10. </props>   
  11. </property>  
<!-- 配置事务属性 -->
<property name="transactionAttributes">
   <props>
<!--指定了 "PROPAGATION_REQUIRED"，表示在当前的事务中执行操作，如果事务不存在就建立一个新的-->
<prop key="delete*">PROPAGATION_REQUIRED,-ProgramException</prop>
<prop key="add*">PROPAGATION_REQUIRED,-ProgramException</prop>
<prop key="update*">PROPAGATION_REQUIRED, -ProgramException</prop>
<prop key="save*">PROPAGATION_REQUIRED, -ProgramException</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>



Spring中对异常的回滚，默认是在抛出运行时异常(RuntimeException)时才回滚，对非运行时异常不回滚。如果使用-Exception,意思是对所有的异常异常都回滚。Exception前面加上 "-" 时，表示发生指定异常时撤消操作(rollback)，如果前面加上 "+"，表示发生异常时立即提交（commit）。
要想用Spring的事务管理机制，就需要把数据库的连接交给Spring来管理，（JDBC,SESSION道理一样），如果使用Hibernate框架，要把Session交给Spring管理。在整个Service方法调用中，虽然Sevice调用了多个Dao，但是整个过程中Session只有一个。也就是说你对数据库的DML操作，都会先保存在这个Session中，包括update,insert,delete。当发生异常（这个异常可以是数据库的，也可以是程序的），Spring会把这个Session中对应的DML操作回滚。
<3>事务的属性
(1) 传播行为

  • PROPAGATION_MANDATORY: 方法必须在一个现存的事务中进行，否则丢出异常
  • PROPAGATION_NESTED: 在一个嵌入的事务中进行，如果不是，则同PROPAGATION_REQUIRED
  • PROPAGATION_NEVER: 指出不应在事务中进行，如果有就丢出异常
  • PROPAGATION_NOT_SUPPORTED: 指出不应在事务中进行，如果有就暂停现存的事务
  • PROPAGATION_REQUIRED: 在当前的事务中进行，如果没有就建立一个新的事务
  • PROPAGATION_REQUIRES_NEW: 建立一个新的事务，如果现存一个事务就暂停它
  • PROPAGATION_SUPPORTS: 支持现在的事务，如果没有就以非事务的方式执行


(2) 隔离层级

  • ISOLATION_DEFAULT: 使用底层数据库预设的隔离层级
  • ISOLATION_READ_COMMITTED: 允许事务读取其他并行的事务已经送出（Commit）的数据字段，可以防止Dirty read问题
  • ISOLATION_READ_UNCOMMITTED: 允许事务读取其他并行的事务还没送出的数据，会发生Dirty、Nonrepeatable、Phantom read等问题
  • ISOLATION_REPEATABLE_READ: 要求多次读取的数据必须相同，除非事务本身更新数据，可防止Dirty、Nonrepeatable read问题
  • ISOLATION_SERIALIZABLE: 完整的隔离层级，可防止Dirty、Nonrepeatable、Phantom read等问题，会锁定对应的数据表格，因而有效率问题


(3) 只读提示（Read-only hints）
如果事务只进行读取的动作，则可以利用底层数据库在只读操作时发生的一些最佳化动作，由于这个动作利用到数据库在只读的事务操作最佳化，因而必须在事务中才有效，也就是说要搭配传播行为PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED来设置。
(4)事务超时期间（The transaction timeout period）
有的事务操作可能延续很长一段的时间，事务本身可能关联到数据表的锁定，因而长时间的事务操作会有效率上的问题，对于过长的事务操作，考虑Roll back事务并要求重新操作，而不是无限时的等待事务完成。
可以设置事务超时期间，计时是从事务开始时，所以这个设置必须搭配传播行为PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED来设置。
事务的超时属性以timeout_为前缀和一个整型数字定义，例如： <prop key="query*">PROPAGATION_REGUIRED,timeout_5,readOnly</prop>

分享到：
| Spring2.X以AspectJ 式AOP 配置事务
评论
发表评论

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

相关推荐

    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事务管理

    Spring事务管理是Spring框架的核心特性之一，它提供了一种在Java应用中管理和协调数据库事务的标准方式。对于有Java基础的开发者来说，理解并掌握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