transactionmanagerspring事务 TransactionTemplate 怎样实现多次提交

什么是JTA？

JTA是只是一组java接口用于描述，J2ee框架中事务管理器与应用程序，资源管理器，以及应用服务器之间的事务通讯。

　　它主要包括高层接口即面向应用程序的接口；XAResource接口即面向资源的接口；以及事务管理器的接口。

值得注意的是JTA只提供了接口，没有具体的实现。

　　JTS是服务OTS的JTA的实现。

简单的说JTS实现了JTA接口，并且符合OTS的规范。

　　资源管理器只要其提供给事务管理器的接口符合XA接口规范，就可以被事务管理器处理。

　　所以，JTA可以处理任何提供符合XA接口的资源。

包括：数据库，JMS，商业对象等等 　　“Java 事务 API”（JTA）启用两阶段提交功能。

　　当配置 WebSphere Application Server 以访问数据库时，可选择具有 JTA 能力的驱动程序。

如果需要两阶段提交功能，则必须使用启用 JTA 的驱动程序。

　　只要在事务中调用了多个数据库连接，就需要 JTA。

只要在事务中调用了多个数据库服务器，就需要两阶段提交。

这些连接可以是相同的物理数据库服务器或多个数据库服务器。

例如：* 实体企业Bean Entity1 在应用程序服务器 AppServer1 中部署。

　　性能实现JTA 启用的连接与非 JTA 启用的连接执行情况不同。

基于此原因，应用程序不需要 JTA，则最好使用非 JTA 启用的驱动程序。

spring的@Transactional为什么不能指定TransactionManager

用过spring的人应该都使用过@Transactional注解了 在只有一个TransactionManager时没有问题 配置如下： Java代码 <!-- 事务配置 --> <bean id="transactionManager" class=&.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> </bean> <!-- 使用annotation定义事务 --> <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="false"/> 如果有两个事务管理器 如 HibernateTransactionManager和 DataSourceTransactionManager 就不好办了 为什么不直接在@Transactional上指定事务管理器呢 比如说这样 Java代码 @Transactional(transactionManager=DataSourceTransactionManager)

spring配置事务管理器有哪些类

<!-- 开启事物 （使用注解）--> <bean id="transactionManager" class=&.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="给一个连接池"></property> </bean> <tx:annotation-driven transaction-manager="transactionManager"/>

如何学习spring的事务管理

Spring 事务管理 Spring是SSH中的管理员，负责管理其它框架，协调各个部分的工作。

今天一起学习一下Spring的事务管理。

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

下面一起看看三种声明式事务的具体配置： 公共配置 <!-- 配置sessionFactory --> <bean id="sessionFactory" class=&.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <property name="configLocation"> <value>classpath:config/hibernate.cfg.xml</value> </property> <property name="packagesToScan"> <list> <value&.entity</value> </list> </property> </bean> <!-- 配置事务管理器（声明式的事务） --> <bean id="transactionManager" class=&.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- 配置DAO --> <bean id="userDao" class=&.dao.UserDaoImpl"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> 第一种，使用tx标签方式 <!-- 第一种配置事务的方式 ，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(*.dao.*.*(..))"/> <aop:advisor pointcut-ref="daoMethod" advice-ref="txadvice"/> </aop:config> expression="execution(.dao..(..))" 其中第一个代表返回值，第二代表dao下子包，第三个代表方法名，“（..）”代表方法参数。

第二种，使用代理方式 <!-- 第二种配置事务的方式 ，代理--> <bean id="transactionProxy" class=&.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=&.dao.UserDaoImpl"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> </property> </bean> 将transactionProxy的abstract属性设置为"true"，然后将具体的Dao的parent属性设置为"transactionProxy"，可以精简代码。

第三种，使用拦截器 <!-- 第三种配置事务的方式，拦截器 (不常用)--> <bean id="transactionInterceptor" class=&.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=&roxy.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 / >，其作用是开启注解的方式。

具体配置如下： <!--开启注解方式--> <context:annotation-config /> <!-- 配置sessionFactory --> <bean id="sessionFactory" class=&.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <property name="configLocation"> <value>classpath:config/hibernate.cfg.xml</value> </property> <property name="packagesToScan"> <list> <value&.entity</value> </list> </property> </bean> <!-- 配置事务管理器 --> <bean id="transactionManager" class=&.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- 第四种配置事务的方式，注解 --> <tx:annotation-driven transaction-manager="transactionManager"/> 注解文件： .dao; .springframework.orm.hibernate3.HibernateTemplate; .springframework.transaction.annotation.Propagation; .springframework.transaction.annotation.Transactional; .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为默认事务配置，如方法没有自己的事务类型，则按默认事务，如有自己的配置，则按自己的配置。

以上四种配置方式最常用的还是第一、二种，第三种是比较老旧的方式，而注解的方式不太适合比较大的项目，用于简单的小项目还是很好的，其特点就是简单明了。

每种方法都有每种方法的特点跟适用的环境，没有绝对的好与坏，只不过前两种在实际的工作当中用的更多一些。

好了，今天就到这里吧，看了这么长的文章，相信大家都累了，也不想再听我在这里废话了，哈哈。

欢迎交流，欢迎拍砖。

OpenSessionInViewFilter原理以及为什么要用OpenSessionInViewF

首先要说明一下Open Session in View的作用，就是允许在每次的整个request的过程中使用同一个hibernate session,可以在这个request任 何时期lazy loading数据。

如果是singleSession=false的话，就不会在每次的整个request的过程中使用同一个hibernate session,而是每个数据访问都会产生各自的seesion,等于没有Open Session in View. OpenSessionInViewFilter默认是不会对session 进行flush的,并且flush mode 是 never 代码: protected Session getSession(SessionFactory sessionFactory) throws essResourceFailureException { Session session = SessionFactoryUtils.getSession(sessionFactory, true); session.setFlushMode(FlushMode.NEVER); return session; } 看getSession的方式就知道,把flush mode 设为FlushMode.NEVER,这样就算mit的时候也不会session flush, 如果想在完成request过程中更新数据的话, 那就需要先把flush model设为FlushMode.AUTO,再在更新完数据后flush. . OpenSessionInView默认的FlushMode为 代码: FlushMode.NEVER ：：：：：：：：：：解决方法：：：：：：：：：：：： 可以采用spring的事务声明解决，示例代码如下： <!-- 声明一个 Hibernate 3 的 事务管理器供代理类自动管理事务用--> <bean id="transactionManager" class=&.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <aop:config> <!-- 切入点指明了在执.ssh2.manager包中的所有方法时产生事务拦截操作 --> <aop:pointcut id="daoMethods" expression="execution(*.ssh2.manager.*.*(..))"/> <!-- 定义了将采用何种拦截操作，这里引用到 txAdvice --> <aop:advisor advice-ref="txAdvice" pointcut-ref="daoMethods"/> </aop:config> ; <!-- 事务通知操作，使用的事务管理器引用自transactionManager --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <!-- 指定哪些方法需要加入事务 --> <tx:method name="getPageTable*" propagation="REQUIRED"/> <tx:method name="getTotalRecodes" propagation="REQUIRED"/> <tx:method name="save*" propagation="REQUIRED"/> <tx:method name="delete*" propagation="REQUIRED"/> <tx:method name="update*" propagation="REQUIRED"/> </tx:attributes> </tx:advice>

spring事务 TransactionTemplate 怎样实现多次提交

DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); TransactionStatus status = transactionManager.getTransaction(def);//设为false