Spring 事务简介

最新推荐文章于 2023-09-09 18:31:39 发布
最新推荐文章于 2023-09-09 18:31:39 发布
阅读量284 收藏 1
点赞数
分类专栏： OpenSource 文章标签： spring bean class dao interceptor c3p0

 Spring中事务的定义：
一、Propagation ：

对于特定的方法或方法命名模式，代理的具体事务行为由事务属性驱动，如下面的例子所示：
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="store*">PROPAGATION_REQUIRED</prop>

　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：

  • PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  • PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
  • PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
  • PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
  • PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

       前六个策略类似于EJB CMT：常量名相同，因此，对EJB开发人员来说，应该立刻就感到熟悉。第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager），或者通过JTA支持嵌套事务。

　　　　

二、Isolation Level(事务隔离等级):
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。

spring中的Isolation属性：
1、ISOLATION_DEFAULT ：使用当前数据源的默认级别
2、ISOLATION_READ_UNCOMMITTED ：Dirty reads, non-repeatable reads, and phantom reads can occur.
3、ISOLATION_READ_COMMITTED :Dirty reads are prevented; non-repeatable reads and phantom reads can occur.
4、ISOLATION_REPEATABLE_READ:Dirty reads and non-repeatable reads are prevented; phantom reads can occur.
5、ISOLATION_SERIALIZABLE:Dirty reads, non-repeatable reads, and phantom reads are prevented.

三、readOnly
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。

四、Timeout

       在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。

事务划分策略

1、推荐在业务层使用事务，这样可以允许业务层捕获导致rollback的异常，并抛出恰当的业务层异常；不在dao层使用事务是因为这会限制了dao重用其他事务需求，并且dao层没有实现业务逻辑，并且原子性也是业务层的概念。

spring声明性事务的划分：
1、有四个地方需要配置：The four participants are transaction manager, proxy factory, transaction interceptor, and a set of transaction attributes.



2、使用ProxyFactoryBean/Transaction Interceptor（transactionInterceptor）配置spring事务

以下为配置实例：

<!-- The DBCP DataSource -->
   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"   
         destroy-method="close">
     <property name="driverClassName">
       <value>${jdbc.driverClassName}</value>
     </property>
     <property name="url"><value>${jdbc.url}</value></property>
     <property name="username"><value>${jdbc.username}</value></property>
     <property name="password"><value>${jdbc.password}</value></property>
   </bean>
    
   <!-- The DAO class -->
   <bean id="dao" 
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean>
    
   <!-- The transactionmanager to use for regular non JTA datasource -->
   <bean id="transactionManager"
     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean>
    
   <!-- TransactionInterceptor -->
   <bean id="transactionInterceptor" 
     class="org.springframework.transaction.interceptor.TransactionInterceptor">
     <property name="transactionManager">
       <ref bean="transactionManager"/>
     </property>
     <property name="transactionAttributeSource">
       <value>
org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS,re
adOnly
org.springframework.prospring.ticket.service.BoxOffice.allocate*=PROPAGATION_REQUIR
ED
       </value>
     </property>
   </bean>   
    
   <!-- Transactional proxy for the primary business object -->
   <bean id="boxOffice" 
         class="org.springframework.aop.framework.ProxyFactoryBean">
     <property name="target">
       <ref local="boxOfficeTarget"/>
     </property>
     <property name="proxyInterfaces">
       <value>org.springframework.prospring.ticket.service.BoxOffice</value>
     </property>
     <property name="interceptorNames">
       <value>transactionInterceptor</value>
     </property>
   </bean>   
    
   <!-- Business Object -->
   <bean id="boxOfficeTarget" 
     class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
     <property name="boxOfficeDao">
       <ref local="dao"/>
     </property> 
   </bean>

3、使用TransactionProxyFactoryBean配置spring事务
以下为配置实例：

   <!-- The DBCP DataSource -->
   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
         destroy-method="close">
     <property name="driverClassName">
       <value>${jdbc.driverClassName}</value>
     </property>
     <property name="url"><value>${jdbc.url}</value></property>
     <property name="username"><value>${jdbc.username}</value></property>
     <property name="password"><value>${jdbc.password}</value></property>
   </bean>
    
   <!-- The DAO class -->
   <bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean>
    
   <!-- The transactionmanager to use for regular non JTA datasource -->
   <bean id="transactionManager"
     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean>
    
   <!-- Transactional proxy and the primary business object -->
   <bean id="boxOffice" 
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
     <property name="transactionManager"><ref bean="transactionManager"/></property>
     <property name="target">
       <bean class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
         <property name="boxOfficeDao">
           <ref local="dao"/>
         </property> 
       </bean>
     </property>
     <property name="transactionAttributes">
       <props>
         <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
         <prop key="allocate*">PROPAGATION_REQUIRED</prop>
       </props>
     </property>
   </bean>  

4、使用BeanNameAutoProxyCreator配置spring事务
如果有大量的bean需要使用事物，那么只要在配置文件中提供bean name给BeanNameAutoProxyCreator，spring就会个给该bean提供事务代理，配置实例如下：

   <!-- The DBCP DataSource -->
   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
       destroy-method="close">
     <property name="driverClassName">
       <value>${jdbc.driverClassName}</value>
     </property>
     <property name="url"><value>${jdbc.url}</value></property>
     <property name="username"><value>${jdbc.username}</value></property>
     <property name="password"><value>${jdbc.password}</value></property>
   </bean>
    
   <!-- The DAO class -->
   <bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean>
    
   <!-- The transactionmanager to use for regular non JTA datasource -->
   <bean id="transactionManager"
     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource">
       <ref local="dataSource"/>
     </property> 
   </bean> 
    
   <!-- TransactionInterceptor -->
   <bean id="transactionInterceptor" 
         class="org.springframework.transaction.interceptor.TransactionInterceptor">
     <property name="transactionManager">
       <ref bean="transactionManager"/>
     </property>
     <property name="transactionAttributeSource">
       <value>
org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS
,readOnly
org.springframework.prospring.ticket.service.BoxOffice.allocate*=
PROPAGATION_REQUIRED
       </value>
     </property>
   </bean>   
    
   <!-- BeanNameAutoProxyCreator -->
<bean id="autoProxyCreator" 
    class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
   <property name="interceptorNames">
     <value>transactionInterceptor</value>
   </property>
   <property name="beanNames">
     <list>
       <idref local="boxOffice"/>
     </list>
   </property>
</bean>   
    
<!-- Business Object -->
<bean id="boxOffice"
    class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
   <property name="boxOfficeDao">
     <ref local="dao"/>
   </property> 
</bean>
以下是配置的一个例子:
web.xml：
<context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/applicationContext-*.xml,/WEB-INF/action-servlet.xml</param-value>
  </context-param>
  <context-param>
     <param-name>log4jConfigLocation</param-name>
     <param-value>/WEB-INF/log4j.properties</param-value>
  </context-param> 
applicationContext-hibernate.xml
<beans>
  <import resource="applicationContext-dao.xml" />
  <import resource="applicationContext-service.xml" />
  <import resource="applicationContext-extend.xml" />
  
 <bean id="propertyConfigurer"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <!--  <value>WEB-INF/mail.properties</value>-->
            <value>WEB-INF/jdbc.properties</value>
            <!--  <value>WEB-INF/oscache.properties</value>-->
        </list>
    </property>
 </bean>
 <!-- MailSender used by EmailAdvice -->
 <!--
     <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
     <property name="host" value="${mail.host}"/>
     </bean>
 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
     destroy-method="close" dependency-check="none">
     <property name="driverClass">
         <value>${datasource.driverClassName}</value>
     </property>
     <property name="jdbcUrl">
         <value>${datasource.url}</value>
     </property>
     <property name="user">
         <value>${datasource.username}</value>
     </property>
     <property name="password">
         <value>${datasource.password}</value>
     </property>
     <property name="acquireIncrement">
         <value>${c3p0.acquireIncrement}</value>
     </property>
     <property name="initialPoolSize">
         <value>${c3p0.initialPoolSize}</value>
     </property>
     <property name="minPoolSize">
         <value>${c3p0.minPoolSize}</value>
     </property>
     <property name="maxPoolSize">
         <value>${c3p0.maxPoolSize}</value>
     </property>
     <property name="maxIdleTime">
         <value>${c3p0.maxIdleTime}</value>
     </property>
     <property name="idleConnectionTestPeriod">
         <value>${c3p0.idleConnectionTestPeriod}</value>
     </property>
     <property name="maxStatements">
         <value>${c3p0.maxStatements}</value>
     </property>
     <property name="numHelperThreads">
         <value>${c3p0.numHelperThreads}</value>
     </property>
 </bean>
 
    <!--定义了Hibernate的SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref local="dataSource"/>
        </property>
        <property name="mappingResources">
            <list>
     <value>Department.hbm.xml</value>
     <value>Employee.hbm.xml</value>
     <value>Region.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">${hibernate.dialect}</prop>
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
            <prop key="hibernate.jdbc.fetch_size">
                ${hibernate.jdbc.fetch_size}
            </prop>
            <prop key="hibernate.jdbc.batch_size">
                ${hibernate.jdbc.batch_size}
            </prop>
        </props>
    </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
     <!--  事务拦截器bean需要依赖注入一个事务管理器 -->
        <property name="transactionManager" ref="transactionManager"/>
     <property name="transactionAttributes">
      <!--  下面定义事务传播属性-->
      <props>
       <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="add*">PROPAGATION_REQUIRED</prop>
                <prop key="remove*">PROPAGATION_REQUIRED</prop>
                <prop key="delete*">PROPAGATION_REQUIRED</prop>
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="change*">PROPAGATION_REQUIRED</prop>
                <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
      </props>
     </property>
 </bean>
    <!-- 定义BeanNameAutoProxyCreator-->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
     <!--  指定对满足哪些bean name的bean自动生成业务代理 -->
     <property name="beanNames">
            <!--  下面是所有需要自动创建事务代理的bean-->
            <list>
                <value>servieceManager</value>
            </list>
            <!--  此处可增加其他需要自动创建事务代理的bean-->
     </property>
        <!--  下面定义BeanNameAutoProxyCreator所需的事务拦截器-->
        <property name="interceptorNames">
            <list>
                <!-- 此处可增加其他新的Interceptor -->
                <value>transactionInterceptor</value> 
            </list>
        </property>
    </bean>
    
</beans>
对于长事务(就是多个数据库的操作)的demo:
配置两个容器管理的数据源、分别配置sessionFactory、最后配置一个Spring提供的JTA事务管理器就行了
<beans>   
    
      <bean   id="myDataSource1"   class="org.springframework.jndi.JndiObjectFactoryBean">   
          <property   name="jndiName   value="java:comp/env/jdbc/myds1"/>   
      </bean>   
    
      <bean   id="myDataSource2"   class="org.springframework.jndi.JndiObjectFactoryBean">   
          <property   name="jndiName"   value="java:comp/env/jdbc/myds2"/>   
      </bean>   
    
      <bean   id="mySessionFactory1"   class="org.springframework.orm.hibernate.LocalSessionFactoryBean">   
          <property   name="dataSource"   ref="myDataSource1"/>   
          <property   name="mappingResources">   
              <list>   
                  <value>product.hbm.xml</value>   
              </list>   
          </property>   
          <property   name="hibernateProperties">   
              <props>   
                  <prop   key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>   
              </props>   
          </property>   
      </bean>   
    
      <bean   id="mySessionFactory2"   class="org.springframework.orm.hibernate.LocalSessionFactoryBean">   
          <property   name="dataSource"   ref="myDataSource2"/>   
          <property   name="mappingResources">   
              <list>   
                  <value>inventory.hbm.xml</value>   
              </list>   
          </property>   
          <property   name="hibernateProperties">   
              <props>   
                  <prop   key="hibernate.dialect">net.sf.hibernate.dialect.OracleDialect</prop>   
              </props>   
          </property>   
      </bean>   
    
      <bean   id="myTxManager"   class="org.springframework.transaction.jta.JtaTransactionManager"/>   
    
      <bean   id="myProductDao"   class="product.ProductDaoImpl">   
          <property   name="sessionFactory"   ref="mySessionFactory1"/>   
      </bean>   
    
      <bean   id="myInventoryDao"   class="product.InventoryDaoImpl">   
          <property   name="sessionFactory"   ref="mySessionFactory2"/>   
      </bean>   
    
      <bean   id="myProductServiceTarget"   class="product.ProductServiceImpl">   
          <property   name="productDao"   ref="myProductDao"/>   
          <property   name="inventoryDao"   ref="myInventoryDao"/>   
      </bean>   
    
      <bean   id="myProductService"   
              class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">   
          <property   name="transactionManager"   ref="myTxManager"/>   
          <property   name="target"   ref="myProductServiceTarget"/>   
          <property   name="transactionAttributes">   
              <props>   
                  <prop   key="increasePrice*">PROPAGATION_REQUIRED</prop>   
                  <prop   key="someOtherBusinessMethod">PROPAGATION_REQUIRES_NEW</prop>   
                  <prop   key="*">PROPAGATION_SUPPORTS,readOnly</prop>   
              </props>   
          </property>   
      </bean>   
    
  </beans>  
老崔
关注
专栏目录
Spring事务和MySQL事务详解面试
用文字记录下每一个瞬间的感动和每一次思考的火花
09-10 23万+
文章目录数据库事务事务是什么事务的四大特性MySQL事务隔离级别查看MySQL当前事务隔离级别MySQL默认操作模式为自动提交模式JDBC处理事务Spring事务Spring的事务传播PROPAGATION_REQUIREDPROPAGATION_SUPPORTSPROPAGATION_MANDATORYPROPAGATION_REQUIRES_NEWPROPAGATION_NOT_SUPPORTEDPROPAGATION_NEVERPROPAGATION_NESTEDSpring事务的隔离级别Spring
jdbc预编译对象，事务，数据库连接池，DButil工具类的书写
adsdsasada的博客
11-24 219
jdbc预编译对象 原始的jdbc使用声明对象进行sql的执行，对于执行的sql参数使用字符串拼接的形式进行添加 Class.forName("com.mysql.jdbc.Driver"); Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/teacher", "root", "root"); Statement statement = con.createStatement(); // 当使用
Spring事务处理
zengjinliang的专栏
06-03 132
Spring中事务的定义： 一、Propagation ： 对于特定的方法或方法命名模式，代理的具体事务行为由事务属性驱动，如下面的例子所示： &lt;prop key="load*"&gt;&lt;/prop&gt; PROPAGATION_REQUIRED,readOnly &lt;prop key="store*"&gt;&lt;/prop&gt; PROPAGATION_REQUIRED...
Spring中的事务
qq_55724067的博客
07-08 160
Spring中的事务 事务的作用：保证数据一致性，保证一组Dao操作能够一起成功，一起失败。 事务应用在哪一层？ Service业务层 事务控制的方式？ JDBC：Connection.setAutoCommit(false); //设置手动提交 Connection.commit(); //提交 Connection.rollback();//回滚 Spring事务管理有两种 声明式事务管理（重点） 在配置文件中配置属性声明，基于AOP方式实现事务操作，...
spring中的事务
java小兵
08-03 916
1）配置文件： 1)注解的形式： spring + mybatis： 说明：mybatis会自动参与到spring事务的管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理不起作用。 <!-- 定义事务管理器...
Spring事务
最新发布
程序三两行
09-09 1066
在⼀个业务流程当中，通常需要多条DML（insert delete update）语句共同联合才能完成，这 多条DML语句必须同时成功，或者同时失败，这样才能保证数据的安全。多条DML要么同时成功，要么同时失败，这叫做事务。
Spring事务处理原理步骤详解
08-19
Spring事务处理原理步骤详解 Spring事务处理原理步骤详解是指在Spring框架中实现事务处理的整个过程，它涉及到事务处理的实现、事务处理原理和事务管理器的配置等几个方面。下面是Spring事务处理原理步骤详解的知识...
深入理解Spring事务原理
09-02
Spring事务管理是Spring框架的核心特性之一，它使得开发者能够在应用层面上轻松地处理数据库事务，无需直接接触底层的事务控制。本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库...
spring 事务传播 demo
06-05
在Spring框架中，事务管理是核心特性之一，它允许开发者以声明式或编程式的方式处理事务。本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将...
Spring事务隔离级别简介及实例解析
08-28
Spring事务隔离级别简介及实例解析 本文主要介绍了Spring事务隔离级别的概念和实例解析，涵盖了四个事务隔离级别：READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ和SERIALIZABLE。同时，文章还提供了相关代码...
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
Spring的事务
weixin_44895829的博客
03-14 1万+
1.什么是事务 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败 （2）典型场景：银行转账 lucy 转账 100 元 给 mary lucy 少 100，mary 多 100 事务四个特性（ACID） （1）原子性 一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做 （2）一致性 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 （3）隔离性 一个事务的执行不能被其他事务干扰...
Spring 中的事务
脏码
10-10 428
1.PlatformTransctionManager 平台事务管理器 （1）TransactionStatus getTransaction(TransactionDefinition definition) 获取事务 （2）void commit(TransactionStatus status)提交事物 （3）void rollback（TransactionStatus status
Spring事务管理框架解析
"Spring事务详解.pdf" 在Spring框架中，事务管理是核心功能之一，它提供了强大而灵活的事务处理机制，使得开发者可以专注于业务逻辑而不必过于关注底层的事务控制。Spring的事务管理分为编程式事务管理和声明式事务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值