Spring的全局事物与局部事物

最新推荐文章于 2022-11-02 14:35:33 发布
最新推荐文章于 2022-11-02 14:35:33 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： Spring 文章标签： spring hibernate bean c3p0 class interceptor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaomin416100569/article/details/5480006
版权
Spring的事物管理
2009-10-14 22:50

事物概念：是由一步或几步基本操作组成的逻辑执行单元。

事物的特性：原子性，一致性，隔离型，持久性。

对事物管理可以采用两个策略：

全局事物：全局事物通常由应用服务器管理，使用JTA.全局事物可跨越对个事物性的资源，保证在多个事物性资源间跨越时资源的一致性。

局部事物：局部事物和特定资源相关，例如,一个和jdbc连接关联的事物。该事物仅能保证对该jdbc连接数据库的一致性。对局部事物，应用服务器不需要参与事物管理，不能保证跨越多个资源的事物的正确性。

Hibernate局部事物：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans default-lazy-init="false">

       <!-- ========================= Start of PERSISTENCE DEFINITIONS ========================= -->

       <bean id="propertyConfigurer"

              class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

              <property name="location">

                     <value>classpath:init.properties</value>

              </property>

       </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="minPoolSize">

                     <value>${c3p0.minPoolSize}</value>

              </property>

              <property name="maxPoolSize">

                     <value>${c3p0.maxPoolSize}</value>

              </property>

              <property name="initialPoolSize">

                     <value>${c3p0.initialPoolSize}</value>

              </property>

              <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->

              <property name="maxIdleTime">

                     <value>${c3p0.maxIdleTime}</value>

              </property>

              <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->

              <property name="acquireIncrement">

                     <value>${c3p0.acquireIncrement}</value>

              </property>

              <property name="maxStatements">

                     <value>${c3p0.maxStatements}</value>

              </property>

              <property name="idleConnectionTestPeriod">

                     <value>${c3p0.idleConnectionTestPeriod}</value>

              </property>

              <property name="numHelperThreads">

                     <value>${c3p0.numHelperThreads}</value>

              </property>

       </bean>

       <!--定义hibernate的sessionFactory-->

       <bean id="sessionFactory"

              class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

              <!--依赖注入数据源，注入正是上文定义的dataSource-->

              <property name="dataSource">

                     <ref local="dataSource" />

              </property>

 

              <property name="mappingResources">

                    <!--以下用来列出所有的po映射文件-->

                     <list>

                            <value>com/cader/bean/TEquipContractTypedict.hbm.xml</value>

                     </list>

              </property>

                    <!--定义hibernate的sessionFactory属性-->

              <property name="hibernateProperties">

                     <props>

                               <!--定义hibernate的连接方言-->

                            <prop key="hibernate.dialect">

                                   ${hibernate.dialect}

                            </prop>

                            <!--定义hibernate的sql语句是否显示-->

                            <prop key="hibernate.show_sql">

                                   ${hibernate.show_sql}

                            </prop>

                            <!--定义hibernate对数据库进行批量删除，批量更新和批量插入的时候的批次大小-->

                            <prop key="hibernate.jdbc.batch_size">

                                   ${hibernate.jdbc.batch_size}

                            </prop>

                            <!--定义hibernate每次从数据库中取出的记录条数-->

                            <prop key="hibernate.jdbc.fetch_size">

                                   ${hibernate.jdbc.fetch_size}

                            </prop>

                            <prop key="hibernate.query.factory_class">

                                   ${hibernate.query.factory_class}

                            </prop>

                     </props>

              </property>

       </bean>

    <!--配置hibernate的事物管理-->

    <!--使用HibernateTransactionManager类，该类是PlatformTransactionManger接口针对采用Hibernate持久化连接的特定实现-->

       <bean id="transactionManager"

              class="org.springframework.orm.hibernate3.HibernateTransactionManager">

              <!--HibernateTransactionManager bean需要依赖注入一个sessionFactory bean的应用-->

              <property name="sessionFactory">

                     <ref local="sessionFactory" />

              </property>

       </bean>

</beans>

Hibernate全局事物

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans >

      

        <!--配置jndi数据源-->

       <bean id="dataSource"

              class="org.springframework.jndi.JndiObjectFactoryBean">

              <！--容器管理数据源的jndi-->

              <property name="jndiName">

                   <value>jdbc/jpetstore</value>

              </property>

             

       </bean>

       <!--定义hibernate的sessionFactory-->

       <bean id="sessionFactory"

              class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

              <!--依赖注入数据源，注入正是上文定义的dataSource-->

              <property name="dataSource">

                     <ref local="dataSource" />

              </property>

 

              <property name="mappingResources">

                    <!--以下用来列出所有的po映射文件-->

                     <list>

                            <value>com/cader/bean/TEquipContractTypedict.hbm.xml</value>

                     </list>

              </property>

                    <!--定义hibernate的sessionFactory属性-->

              <property name="hibernateProperties">

                     <props>

                              <!--定义hibernate的连接方言-->

                            <prop key="hibernate.dialect">

                                   ${hibernate.dialect}

                            </prop>

                            <!--定义hibernate的sql语句是否显示-->

                            <prop key="hibernate.show_sql">

                                   ${hibernate.show_sql}

                            </prop>

                            <!--定义hibernate对数据库进行批量删除，批量更新和批量插入的时候的批次大小-->

                            <prop key="hibernate.jdbc.batch_size">

                                   ${hibernate.jdbc.batch_size}

                            </prop>

                            <!--定义hibernate每次从数据库中取出的记录条数-->

                            <prop key="hibernate.jdbc.fetch_size">

                                   ${hibernate.jdbc.fetch_size}

                            </prop>

                            <prop key="hibernate.query.factory_class">

                                   ${hibernate.query.factory_class}

                            </prop>

                     </props>

              </property>

       </bean>

    <!--使用JtaTransactionManager类，该类是PlatformTransactionManger接口针对采用数据源连接的特定实现-->

    <!---JtaTransactionManager不需要知道数据源，或任何其他特定资源 因为使用容器的全局事物管理-->

       <bean id="transactionManager"

              class="org.springframework.transaction.jta.JtaTransactionManager">

 

       </bean>

      

</beans>

根据bean Name 自动创建事物代理：

<!--定义事物拦截器-->

<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="find*">PROPAGATION_REQUIRED,readOnly</prop>

                     <prop key="*">PROPAGATION_REQUIRED</prop>

              </props>

       </property>

       </bean>

 

    <!-- 定义BeanNameAutoProxyCreator-->

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

       <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

           <property name="beanNames">

            <!-- 下面是所有需要自动创建事务代理的bean-->

            <list>

                 <value>test1</value>

                <value>test2</value>

            </list>

            <!-- 此处可增加其他需要自动创建事务代理的bean-->

           </property>

           (2)<!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

           <property name="beanNames">

                <value>*DAO,*.Service</value>

           </property>

        <!-- 下面定义BeanNameAutoProxyCreator所需的事务拦截器-->

        <property name="interceptorNames">

            <list>

                <value>transactionInterceptor</value>

                    <!-- 此处可增加其他新的Interceptor -->

             </list>

        </property>

</bean>

使用bean继承简化事物代理的配置

<bean id="test1" class="lee.TransactionTestImpl">

              <property name="sessionFactory">

                     <ref bean="sessionFactory" />

              </property>

       </bean>

<!--定义所有事物代理bean模板-->

<bean id="txProxyTemplate" abstract="true"

              class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

              <property name="transactionManager">

                     <ref bean="transactionManager" />

              </property>

              <property name="transactionAttributes">

                     <props>

                            <prop key="insert*">

                                   PROPAGATION_REQUIRED,-com.cader.web.util.ChisException

                            </prop>

                            <prop key="add*">

                                   PROPAGATION_REQUIRED,-com.cader.web.util.ChisException

                            </prop>

                            <prop key="save*">

                                   PROPAGATION_REQUIRED,-com.cader.web.util.ChisException

                            </prop>

                           

                     </props>

              </property>

       </bean>

<!--让事物代理bean继承模板bean-->

<bean id="testTrans1" parent="txProxyTemplate">

        <property name="target">

            <ref local="test1"/>

        </property>

    </bean>

liaomin416100569
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring事物
05-22
spring事物的代码案例。spring事物的代码案例。spring事物的代码案例。
Spring事务机制详细解读
雨落成追忆
02-03 4320
JAVE EE传统的事务机制  通常有两种策略：全局事务和局部事务。全局事务可以跨多个事务性资源（即数据源，典型的是数据库和消息队列），通常都需要J2EE应用服务器的管理，其底层需要服务器的JTA支持。而局部事务则与底层采用的持久化技术有关，如果底层直接使用JDBC，需要用Connection对象来操事务。如果采用Hibernate持久化技术，则需要使用session对象来操作事务。  （1）
Spring 数据访问之事务管理
luccs624061082的专栏
10-08 692
Spring 框架事务管理简单介绍
全局和本地事务(从理论上)
涂作权的博客
09-22 1696
全局和本地事务 ·   全局事务 － 资源管理器管理和协调的事务，可以跨越多个数据库和进程。资源管理器一般使用 XA二阶段提交协议与“企业信息系统”(EIS) 或数据库进行交互。 ·   本地事务 － 在单个 EIS 或数据库的本地并且限制在单个进程内的事务。本地事务不涉及多个数据来源。 本地和全局事务都使用 javax.transaction.UserTransaction 接口划分界限，
《软件架构探索》事务处理(1) - 本地事务、全局事务
qq_18208265的博客
01-17 344
在我的博客阅读本文会有更好的阅读体验哦！博客： www.lxiaocode.com 更多内容可以到我博客浏览： www.lxiaocode.com B站算法动画： https://space.bilibili.com/22392939 事务处理（1） 事务处理保证了系统中所有的数据都是符合期望、互相关联的数据之间不会产生矛盾，即数据状态的 {% span red, 一致性（Consistency） %} 。 达成一致性需要三个方面共同努力来保障： {% span red, 原子性（Atomic） %.
spring笔记之事务
huangzihao100的专栏
09-07 479
java ee传统事务有两种策略: 1.全局事务 JTA全局事务 Transaction  ts = ctx.lookup(..); //业务逻辑 tx.commit(); tx.rollback(); 2.局部事务 2.1.JDBC局部事务 Connection conn = getConnection(..); conn.setAutoCommit(false); //业
【Spring】事务管理
刘亚男
09-01 309
跨越不同事物API，支持声明式事务， 用于编程事务管理的API比JTA等复杂事务API更简单， 与Spring数据访问抽象的完美集成
Spring简介、框架核心、优缺点、应用场景
热门推荐
ThinkWon的博客
10-29 4万+
文章目录Spring简介Spring的设计目标Spring的优缺点优点缺点Spring的应用场景 Spring简介 Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，为开发Java应用程序提供全面的基础架构支持。Sprin...
spring事物管理机制视频
07-22
资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
spring-tx事物源码
09-25
该资源是Spring源码中事物的源代码，本资源已经经过编译，只需要导入工程即可。
spring事物和rabbitMQ的例子
08-15
spring的2个数据源的配置，并且每个数据源都配置了事物管理。还有rabbitMQ的发送端代码。本人项目亲自用到的，可以运行。
spring事物传播propagation类别含义详解
08-25
主要介绍了spring事物传播propagation类别含义详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
全局事务和局部事务
xiaoguang0904的专栏
10-31 3090
对于事务管理，J2EE开发者有两种选择：全局事务和局部事务。 1、全局事务        全局事务由应用服务器通过JTA进行管理。以前，使用全局事务比较流行的方法是采用EJB CMT，CMT是声明式事务管理的一种形式（区别于编程式事务管理）。尽管使用EJB本身就需要使用JNDI ，EJB CMT不需要事务相关的JNDI lookups。EJB CMT不需要编写大量的Java代码来控制事务。使
事务管理详细说明及Spring事务管理
m0_59860403的博客
01-26 1286
什么是事务 事务是由N步数据库操作序列组成的逻辑执行单元，这系列操作要么全执行，要么全放弃执行。 事务的特性(ACID) 原子性(Atomicity)：事务是应用中不可再分的最小执行体 一致性(Consistency)：事务执行的结果，须使数据从一个一致性状态，变为另一个一致性状态 隔离性(Isolation)：各个事务的执行互不干扰，任何事务的内部操作对其他的事务都是隔离的 持久性(Durability)：事务一旦提交，对数据所做的任何改变都要记录到永久存储器中。 事务的隔离性 常见的并发异
Spring事务管理
caisongcheng_good的博客
06-26 703
Spring事务Java EE应用的传统事务有两种策略：全局事务和局部事务。全局事务由应用服务器管理，需要底层服务器的JTA支持。局部事务和底层所采用的持久化技术有关，当采用JDBC持久化技术时，需要使用Connection对象来操作事务。全局事务可以跨多个事务性资源（比如说多个数据库和消息队列）；使用局部事务，应用服务器不需要参与事务管理，因此不能保证多个事务性资源的事务正确性。全局事务和局部事...
SpringBoot 全局事务配置
sout-lanys
11-02 7855
传统springboot实现事务只需要在方法上添加@Transactional注解，但是需要在所有的service都加上事务，相对比较麻烦，随着项目的庞大，功能模块会随之增多，所以就需要采用AOP的方式实现全局事务处理。 全局事务配置通过AOP切面指定方法前缀切入点，从而对指定的方法统一进行事务控制，根据方法名前缀来匹配到具体方法，进行事务配置
分布式事务实践(三)--Spring的全局事务JTA
做Java整整10年，目前是教别人写代码，嘿嘿
10-29 1180
01.Spring的本地事务 Spring本身提供了一套Spring容器中进行事务管理的接口: 不同的数据源厂商对Spring提供的事务管理接口都有相应的实现. 而在Spring的容器内,调用者实际上是通过调用Spring的事务接口来实现事务的管理. 02. 容器内存在多个数据源时 如果一个应用容器中存在多个不同的数据源,通常我们会创建多个数据源的事务管理器. 比如一个Java应用要连数据库,同时也要连接MQ,这种情况下进行事务管理,我们就会创建一个DataSourceTransac..
Spring的事务使用
辉之素狂
01-05 599
大家好，今天小辉就讲一下Spring的事务。事务百度上的解释是 这个事务解释很明确哈就是要做的或所做的事情，在数据库中其实就是你要执行的语句，你要执行多少条语句，这些语句顺序怎样执行的你都可以通过事务来控制，事务还有一个特性就是可以后悔，对已经执行的语句进行回滚，（小辉开车中：想拥有这个特性呢）。转回来 ，Spring 事务其实就是对数据库事务的支持了。Spring 事务的隔离级别和数据库...
org.springframework.dao.DataAccessResourceFailureException Io 异常: tConnection reset
liaomin416100569的专栏
04-07 3万+
最近程序老是出现等待一会后 操作程序页面 出现下面异常 org.springframework.dao.DataAccessResourceFailureException Io 异常: tConnection reset   通过测试是发现是dbcp连接池导致 因为服务器释放了 连接 浏览器客户端 没法检测到 当再次访问时 不会重新生成连接   所以通过配置 datasource.v
springcloud 事物
最新发布
08-17
Spring Cloud 提供了一些解决方案来处理分布式事务。 1. 基于本地消息的事务（Transactional Message） 使用消息中间件，如 RabbitMQ 或 Apache Kafka，将事务操作转换成消息发送。然后，在每个微服务中，通过监听...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值