java 事务异常transaction error，need to rollback.duplicate会缓存吗

开始事务提交事务回滚事务

用过spring的人应该都使用过@Transactional注解了在只有一个TransactionManager时没有问题配置如下：Java代码 <!-- 事务配置 --> <bean id="transactionManager" class="org.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)

访问数据库时提供对事务的管理。

DataSourceTransactionManager：事务管理器 对JDBC（Java Data Base Connectivity,java数据库连接）进行事务管理，在spring中是对JdbcTemplate进行事务管理 扩展： HibernateTransactionManager：是对Hibernate进行事务管理，当在spring中使用Hi...

原因一：如果你在Service层使用了@Transactional注解事务，那么请确定您是否定义了事务管理器，并且添加了事务驱动，如下所示：<!-- 定义事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean><!-- 开启事务控制的注解支持 --><tx:annotation-driven transaction-manager="transactionManager"/>原因二：如果你使用了AOP切面事务，请确定Spring Aop Execution表达式是否正确的扫描了Service层接口或实现类，如下所示：<!-- 定义事务策略 --><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!-- 所有以query开头的方法都是只读的<tx:method name="query*" read-only="true" /><tx:method name="get*" read-only="true" /><tx:method name="find*" read-only="true" /><tx:method name="select*" read-only="true" /><!-- 其他方法使用默认事务策略 --><tx:method name="*" rollback-for="Throwable"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="myPointcut" expression="execution(* com.voavoice.service.*.*(..))" /><!-- 将定义好的事务处理策略应用到上述的切入点 --><aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut" /></aop:config>原因三：这是最应该注意的一点，在springmvc xml视图解析器配置中，很多人在<context:component-scan>自动扫描时本来只需要扫描Controller的，但是他扫描的范围过大，扫描了所有的包，会造成事务失效，如下：<!-- 描述conctroller --><context:component-scan base-package="com.voavoice.english.controller"/><!-- 错误的扫描成如下这样 --><context:component-scan base-package="com.voavoice.english"/>所以在springmvc配置中最好只扫描Controller下面的类，而在spring context上下文配置中把扫描范围放大就不会有事！原因四：还可能是pring AOP代理不支持类内部方法调用导致的，就是同一个Service中a方法调用b方法。Spring官方也不推荐使用类内部方法相互调用，一个是代理对象、一个是目标对象，Spring没办法对目标对象进行事务切面处理。有很多成熟的方案可以解决这个问题，比如开启AOP代理ThreadLocal支持或者Service中声明一个自我的引用对象，通过这个自我引用对象（代理对象）开启事务，还有一个方案就是通过实现BeanPostProcessor 接口取得代理对象。例如：1、在XML配置文件中增加<aop:aspectj-autoproxy expose-proxy="true"/><!—注解风格支持--> <aop:config expose-proxy="true"><!—xml风格支持--> 2、修改的业务实现类AService中a()调用this.b();-----------修改为--------->((AService) AopContext.currentProxy()).b();a()可以不开启事务，b()开启事务即可。原因五：手动回滚之前必须声明该方法被事务管理@Transactional(rollbackFor = Exception.class)，此时手动回滚才能生效，事务注解相当于开启事务transactionManager.commit(status);所以，@Transactional(rollbackFor = Exception.class)+TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();原因六：开启事务的方法必须声明为public综上所述，这是最全的解决资料了，我就是参考以上步骤解决了问题。

TransactionTemplate 没有使用抽象类,在它的execute()方法里定义事务处理的骨架代码.但execute()方法的TransactionCallback参数却是个接口,在这接口中定义了doInTransaction()方法 只要实现TransactionCallback接口,并在doInTransaction()方法里编写具体要进行的事务处理的代码就可以 了.

1、@Transactional使用位置 Ⅰ 写在接口类上，该接口的所有实现类的所有方法都会有事务； Ⅱ 写在接口方法上，该接口的所有实现类的该方法都会有事务； Ⅰ 写在实现类上，该类中的所有方法都会有事务； Ⅱ 写在实现类方法上，该方法上有事务。 建议：写在实现类或实现类的方法上。 2、PlatformTransactionManager PlatformTransactionManager是Spring中的事务管理接口，具体如下： 3、DataSourceTransactionManager Spring中JDBC事务管理实现类是DataSourceTransactionManager，所以我们使用MyBatis时，如果需要进行事务管理则配置该事务管理即可。 1、基础准备 jdbc.properties如下： JdbcConfig如下： 2、测试 1、相关注解 配置类注解，定义在配置类上。 设置当前Spring环境中开启注解式事务支持。 接口、类、方法注解，定义在接口、类、方法上。 为当前业务层方法添加事务（如果设置在类或接口上方则类或接口中所有方法均添加事务）。 2、事务角色 发起事务方，在Spring中通常指代业务层开启事务的方法。 加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法。 3、@Transactional常用属性 true只读事务，false读写事务，增删改要设为false，查询设为true。 设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。 当出现指定异常进行事务回滚。 4、事务传播行为 比如上述测试案例中，我们给log方法上的@Transactional设置了传播属性为REQUIRES_NEW，表示当前事务协调员会自己开启一个事务。并不会因为transfer发生回滚而回滚。 Ⅰ REQUIRED（默认）； Ⅱ SUPPORTS； Ⅲ MANDATORY； Ⅳ REQUIRES_NEW； Ⅴ NOT_SUPPORTED； Ⅵ NEVER； Ⅶ NESTED。 以上即为Spring AOP-事务管理的全部内容，感谢阅读。

针对不同资源的事务操作。。。spring分别提供了大量的PlatfromTransactionmanager：针对JDBC DataSource ：DataSourceTransactionManagerHibernate SessionFactory：HibernateTransactionManagerJPA EntityManagerFactory：JpaTransactionManager分布式2PC资源：JtaTrasactionManager此外。。。Spring还针对Weblogic、OC4J、WebSphere提供了单独的事务管理器。Weblogic：WeblogicJtaTransactionManagerOC4J：OC4JJtaTransactionManagerWebSphere：WebSphereUowTransactionManager

看着上面的写了那么多，有很大的压力啊，结果只能告诉你不知道了！

Java种运用了大量的事务管理，就是对一系列的数据库操作进行统一的提交或回滚操作，比如说做一个转账功能，要更改帐户两边的数据，这时候就必须要用事务才能算是严谨的做法。要么成功，要么失败，保持数据一致性。如果中间有一个操作出现异常，那么回滚之前的所有操作。 在strut2框架中为了避免多个用户同时访问服务器，都会使用事务管理来管理访问的人数。

Spring事务管理接口：PlatformTransactionManager、TransactionDefinition和TransactionStatus Spring 的事务管理是基于 AOP 实现的，而 AOP 是以方法为单位的。Spring 的事务属性分别为传播行为、隔离级别、只读和超时属性，这些属性提供了事务应用的方法和描述策略。 在 Java EE 开发经常采用的分层模式中，Spring 的事务处理位于业务逻辑层，它提供了针对事务的解决方案。 在 Spring 解压包的 libs 目录中，包含一个名称为 spring-tx-3.2.13.RELEASE.jar 的文件，该文件是 Spring 提供的用于事务管理的 JAR 包，其中包括事务管理的三个核心接口：PlatformTransactionManager、TransactionDefinition 和 TransactionStatus。 将该 JAR 包的后缀名 jar 改成 zip 的形式后，解压压缩包，进入解压文件夹中的 orgspringframework ransaction 目录后，该目录中的文件如图 1 所示。 图 1 事务管理核心接口 在图 1 中，方框所标注的三个文件就是本节将要讲解的核心接口。这三个核心接口的作用及其提供的方法如下。 PlatformTransactionManager 接口是 Spring 提供的平台事务管理器，用于管理事务。该接口中提供了三个事务操作方法，具体如下。 在项目中，Spring 将 xml 中配置的事务详细信息封装到对象 TransactionDefinition 中，然后通过事务管理器的 getTransaction() 方法获得事务的状态（TransactionStatus），并对事务进行下一步的操作。 TransactionDefinition 接口是事务定义（描述）的对象，它提供了事务相关信息获取的方法，其中包括五个操作，具体如下。 在上述五个方法的描述中，事务的传播行为是指在同一个方法中，不同操作前后所使用的事务。传播行为的种类如表 1 所示。 表 1 传播行为的种类 在事务管理过程中，传播行为可以控制是否需要创建事务以及如何创建事务。 通常情况下，数据的查询不会改变原数据，所以不需要进行事务管理，而对于数据的增加、修改和删除等操作，必须进行事务管理。如果没有指定事务的传播行为，则 Spring3 默认的传播行为是 required。 TransactionStatus 接口是事务的状态，它描述了某一时间点上事务的状态信息。其中包含六个操作，具体如表 2 所示。 表 2 事务的操作

使用maven jetty 插件，并不会打成war包然后部署到jetty。。。 它是以嵌入式方式运行，jetty 直接监控某个运行目录，当文件发生变化时，如果新编译了修改的文件，它会作出相应的加载，这非常适合增量开发。

这里以 MySQL 为例，其 MyISAM 引擎是不支持事务操作的，InnoDB 才是支持事务的引擎，一般要支持事务都会使用 InnoDB。 根据 MySQL 的官方文档： https://dev.mysql.com/doc/refman/5.5/en/storage-engine-setting.html 从 MySQL 5.5.5 开始的默认存储引擎是：InnoDB，之前默认的都是：MyISAM，所以这点要值得注意，底层引擎不支持事务再怎么搞都是无济于事。 如下代码所示，当前数据源若没有配置事务管理器，那也是白搭！ @Bean public PlatformTransactionManager transactionManager(DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } 如果此时把 @Service 注解注释掉，这个类就不会被加载成一个 Bean，那这个类就不会被 Spring 管理了，事务自然就失效了。 以下引自spring官方文档： 大致意思是： @Transactional 只能用于 public 的方法上，否则事务会失效。如果要用在非 public 方法上，可以开启 AspectJ 代理模式。 例1： 例1 中，update方法上面没有加 @Transactional 注解，调用有 @Transactional 注解的 updateOrder 方法，updateOrder 方法上的事务管用吗？ 例2： 例2 中，update方法上面加了 @Transactional 注解，调用有 @Transactional 注解的 updateOrder 方法，updateOrder 方法上的事务管用吗？ 很遗憾，这两个例子中， updateOrder 方法上的事务都不管用 因为它们发生了自身调用，就是调该类自己的方法，而没有经过 Spring 的代理类，默认只有在外部调用事务才会生效，这也是老生常谈的经典问题了。 6.1这个也是出现比较多的场景：把异常吃了，然后又不抛出来，事务也不会回滚！ 6.2 这样事务也是不生效的，因为默认回滚的是：RuntimeException，如果你想触发其他异常的回滚，需要在注解上配置一下，如： @Transactional(rollbackFor = Exception.class) 这个配置仅限于 Throwable 异常类及其子类。 Propagation.NOT_SUPPORTED：表示不以事务运行，当前若存在事务则挂起。这表示不支持以事务的方式运行，所以即使事务生效也是白搭！

你的问题是啥？

在SpringSide 3 中，白衣提供的预先配置好的环境非常有利于用户进行快速开发，但是同时也会为扩展带来一些困难。最直接的例子就是关于在项目中使用多个数据源的问题，似乎 很难搞。在上一篇中，我探讨了SpringSide 3 中的数据访问层，在这一篇中，我立志要解决多数据源配置的难题，我的思路是这样的：第一步、测试能否配置多个DataSource第二步、测试能否配置多个SessionFactory第三步、测试能否配置多个TransactionManager第四步、测试能否使用多个TransactionManager，也就是看能否配置多个基本上到第四步就应该走不通了，因为Spring中似乎不能配置多个，而且@transactional注解也无法让用户选择具体使用哪个TransactionManager。也就是说，在SpringSide的应用中，不能让不同的数据源分别属于不同的事务管理器，多数据源只能使用分布式事务管理器，那么测试思路继续如下进行：第五步、测试能否配置JTATransactionManager如果到这一步，项目还能顺利在Tomcat中运行的话，我们就算大功告成了。但我总认为事情不会那么顺利，我总觉得JTATransactionManager需要应用服务器的支持，而且需要和JNDI配合使用，具体是不是这样，那只有等测试后才知道。如果被我不幸言中，那么进行下一步：第六步、更换Tomcat为GlassFish，更换JDBC的DataSource为JNDI查找的DataSource，然后配置JTATransactionManager下面测试开始，先假设场景，还是继续用上一篇中提到的简单的文章发布系统，假设该系统运行一段时间后非常火爆，单靠一台服务器已经无法支持巨大的用户数， 这时候，站长想到了把数据进行水平划分，于是，需要建立一个索引数据库，该索引数据库需保存每一篇文章的Subject及其内容所在的Web服务器，而每 一个Web服务器上运行的项目，需要同时访问索引数据库和内容数据库。所以，需要创建索引数据库，如下：[java] view plain copy print?create database puretext_index; use puretext_index; create table articles( id int primary key auto_increment, subject varchar(256), webserver varchar(30) ); create database puretext_index;use puretext_index;create table articles(id int primary key auto_increment,subject varchar(256),webserver varchar(30));第一步测试，配置多个DataSource，配置文件如下：application.properties

我是这样看的第一个机制称为A，第二个为B，当同时使用是A机制并不会影响B，但B机制发生错误操作会使A机制的已完成操作回滚，虽然不会造成死锁，但是由于其他已完成操作应B的失败处理机制会回滚。

首先 @Transaction 是属于 Spring部分的下面来说说使用spring中的@Transaction配置详解1、Spring默认Transactional事物管理机制如果程序抛出的是运行期例外，则数据回滚 事物处理如果是重新Exception例外，则数据不会滚。可以通过配置修改该规则@Transactional(noRollbackFor=RuntimeException.class)方法事物说明@Transactional(RollbackFor=Exception.clas)@Transactional(readyOnly=true)@Transactional(timeout=100)默认30@Transactional(isolation)数据库的隔离级别{Read Uncommited:读取未提交的数据(会出现脏读 不可重复读 幻读)Read Commited:读已提交的数据(会出现不可重复读和幻读)Repeatable Read:可重复读(会出现幻读)Serializable:串行化}脏读:一个事务读取到另外一个事务未提交的更新的数据不可重复读:在同一个事务中，多次读取同一个数据返回结果有所不同，就是后续的读取可以读到另外一个事务的已经提交的更新数据可重复读:在同一个事务多次读取数据时，能够保证所读取的数据一样，也就是后读取的不能读到另外一个事务已经提交的数据幻读: 一个事务读取到另外一个事务已经提交的更新的数据针对查询方法@Transactional(propagation=Propagation.NOT_SUPPORTED)针对某个方法不开启事务@Transactional(propagation=Propagation.REQUIRED)spring默认的事务支持Propagation参数解析1、REQUIRED:业务方法需要在一个事务中运行。如果方法运行中，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。2、NOT_SUPPORIED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。3、REQUIRES_NEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起， 新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。4、MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器会抛出例外。5、SUPPORTS:这一事务属性表明，如果业务方法在某一个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。6、NEVER：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。7、NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独事的事务， 这个事务拥有多个 可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只会对DataSourceTransactionManager事务管理器起效。

你xml全部发出来看下，而且说下你的问题是什么。

所以尽管 MyBatis3 提供了对 Spring 的整合,但是 org.springframework.jdbc.datasource.DataSourceTransactionManager 这个事务管理 器还是不支持

jdbc数据库连接

要用spring.jar里面的，因为这个注解是事务管理用的。public class MultiTxService { @Transactional("tran_1") public void addTest(int id){ } @Transactional("tran_2") public void deleteTest(int id){ }}

类找不到,...java扩展包中的事务管理类.如果你的项目中用了spring,那么就是spring跟其他orm框架进行整合的时候所用到的类.

可以，Spring的事务处理能力是最综合完整的，对编程式、声明式均进行了支持，而且可以在不使用应用服务器的情况下兼容应用服务器事务。下面的是一个分布式的声明事务，访问多个数据源的配置：<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans default-autowire="byName"><!-- Configurer that replaces ${...} placeholders with values from a properties file --> <!-- (in this case, JDBC-related settings for the dataSource definition below) --> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:spring/jdbc.properties</value> </list> </property> </bean> <bean id="dataSourceMysql" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close"> <property name="uniqueResourceName" value="${mysql.uniqueResourceName}" /> <property name="xaDataSourceClassName" value="${mysql.xaDataSourceClassName}" /> <property name="xaProperties"> <props> <prop key="user">${mysql.user}</prop> <prop key="password">${mysql.password}</prop> <prop key="URL">${mysql.url}</prop> </props> </property> <property name="poolSize" value="${mysql.poolSize}" /> </bean> <bean id="dataSourceOracle" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close"> <property name="uniqueResourceName" value="${oracle.uniqueResourceName}" /> <property name="xaDataSourceClassName" value="${oracle.xaDataSourceClassName}" /> <property name="xaProperties"> <props> <prop key="user">${oracle.user}</prop> <prop key="password">${oracle.password}</prop> <prop key="URL">${oracle.url}</prop> </props> </property> <property name="poolSize" value="${oracle.poolSize}" /> </bean> <!-- Construct Atomikos UserTransactionManager, needed to configure Spring --> <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close"> <!-- when close is called, should we force transactions to terminate or not? --> <property name="forceShutdown" value="${transactionManager.forceShutdown}" /> </bean> <!-- Also use Atomikos UserTransactionImp, needed to configure Spring --> <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp"> <property name="transactionTimeout" value="${transactionManager.transactionTimeout}" /> </bean> <!-- Configure the Spring framework to use JTA transactions from Atomikos --> <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"> <property name="transactionManager"> <ref bean="atomikosTransactionManager" /> </property> <property name="userTransaction"> <ref bean="atomikosUserTransaction" /> </property> </bean> <bean id="txManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true"> <property name="transactionManager"> <ref bean="transactionManager" /> </property> <property name="transactionAttributes"> <props> <prop key="save*">PROPAGATION_REQUIRED, +AuaException</prop> </props> </property> </bean> <bean id="studentOracleDao" class="com.aua.dao.oracle.StudentDao" /> <bean id="studentMysqlDao" class="com.aua.dao.mysql.StudentDao" /> <bean id="studentService" parent="txManager"> <property name="target"> <bean class="com.aua.service.impl.StudentService" /> </property> </bean></beans>

用 OLE DB、ODBC、ADO或 DB-Library 编写的应用程序使用 Transact-SQL 分布式事务的方法可以是，发出 Transact-SQL 语句启动和停止 Transact-SQL 分布式事务。但是，OLE DB 和 ODBC 还包含在 API 层对管理分布式事务的支持。OLE DB 和 ODBC 应用程序可以使用这些 API 函数管理包括其它 COM资源管理器（支持 MS DTC 事务而非 Microsoft&reg; SQL Serveru2122）的分布式事务。它们也可以使用 API 函数获取对包括多个 SQL Server 的分布式事务边界的更多控制。ODBC 分布式事务通过将连接特性 SQL_ATTR_AUTOCOMMIT 设置为 SQL_AUTOCOMMIT_OFF，然后调用 ODBCSQLEndTran函数提交或回滚每个事务，可以控制 ODBC API 层的本地事务。不要使用这些函数管理 ODBC 应用程序中的分布式事务。而应该使用 MS DTC COM 方法：● 调用 DtcGetTransactionManager 连接到 MS DTC。● 调用 ITransactionDispenser::BeginTransaction 启动分布式事务并获取事务对象。● 对每个参与分布式事务的 ODBC 连接，调用 ODBC 函数 SQLSetConnectAttr，其中 fOption 设置为 SQL_COPT_SS_ENLIST_IN_DTC，vParam 控制来自 ITransactionDispenser::BeginTransaction 的事务对象的地址。● 当事务完成时，对于从 ITransactionDispenser::BeginTransaction 获得的事务对象，不要调用 ODBC SQLEndTran 函数，应该调用 ITransaction::Commit 或 ITransaction::Rollback 方法。OLE DB 分布式事务控制 OLE DB 中的分布式事务的方法与控制本地事务的方法相似。若要控制本地事务，则 OLE DB 的使用者应该：● 使用 ITransactionLocal::StartTransaction 方法启动本地事务，并获得事务对象。● 然后使用者在从 ITransactionLocal::StartTransaction 获得的事务对象上，调用 ITransaction::Commit 或 ITransaction::Rollback 方法。若要控制分布式事务，使用者应该： ● 调用 DtcGetTransactionManager 连接到 MS DTC。● 调用 ITransactionDispenser::BeginTransaction 启动分布式事务，并获得事务对象。● 对每个参与分布式事务的连接，调用分布式事务对象的 ITransactionJoin 接口。● 调用分布式事务对象的 ITransaction::Commit 或 ITransaction::Rollback 方法，完成该事务。

做是肯定可以。但是不怎么好。首先action应该只有具有请求services与基本逻辑控制，真正的业务处理与数据交互应该是放在service层。所以事物在这里再好不过了。建议考虑一下如果要配置，把之前spring配置路径改成action的，然后在方法上加上Transactional注解就可以了吧。不知道你系统是不是这样。谢谢。

<bean name="user" 就一个吧？

按lz你的配置SaUserDAO userdao=(SaUserDAO)context.getBean("SaUserDAO")这句注入的是SaUserDAO而不是代理对象userDAOProxy

使用和提交回滚在未提交或者回滚时连接中断会出错

no transaction manager, lookup configured没有事务管理器，查找配置

hibernate已经对jdbc进行了封装Transaction.begin()是对事务处理进行封装，我们拿来用就行了。mybatis虽然也进行了部分的封装但是基本上还是sql为主。这种情况就要求我们自己主动进行事务处理，提交（commit）回滚（rollback），但是不同数据库还是有不同特性，比如说mysql他的擎InnoDB提供自动事务处理。

可以考虑并发的因素。你这段程序做下压力测试，看看是不是有性能瓶颈或者程序bug，有可能是你程序漏洞导致数据库连接无法正常关闭引起的问题，另外建议你用Jndi的方式来访问数据库。

注册DAO

Could not synchronize database state with session错在这里，好像是session问题，因为spring已经管理了session。所以就不要在写了。

Spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活方便。 1、传统使用JDBC的事务管理 以往使用JDBC进行数据操作，使用DataSource，从数据源中得到Connection，我们知道数据源是线程安全的，而连接不是线程安全的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC等这些J2EE商业容器都提供了这个功能。 以往的我们使用JDBC在写代码时，事务管理可能会是这样： Connection conn = null; try{conn = DBConnectionFactory.getConnection;conn.setAutoCommit(false);//do somethingconn.commit(); //commit transcation }catch(Exception e){conn.rollback(); } finally{try{conn.close();} catch(SQLException se){ //do sth.}//close ResultSet,PreparedStatement,Connection//notice:Maybe ocurr Exception when u close rs,pstmt,conn } 按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常，但是这样做会导致额外的麻烦。 2、Spring提供的编程式的事务处理 Spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager，我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 我们使用编程式的事务管理流程可能如下： (1) 声明数据源。 (2) 声明一个事务管理类，例如：DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等 (3) 在我们的代码中加入事务处理代码： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try{//do sthtransactionManager.commit(ts); }catch(Exception e){transactionManager.rollback(ts);} 使用Spring提供的事务模板TransactionTemplate： void add() {transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}} } TransactionTemplate也是为我们省去了部分事务提交、回滚代码；定义事务模板时，需注入事务管理对象。 3、Spring声明式事务处理 Spring声明式事务处理也主要使用了IoC，AOP思想，提供了TransactionInterceptor拦截器和常用的代理类TransactionProxyFactoryBean，可以直接对组件进行事务代理。 使用TransactionInterceptor的步骤： （1）定义数据源，事务管理类 （2）定义事务拦截器,例如： ＜bean id = "transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"＞ ＜property name="transactionManager"＞＜ref bean="transactionManager"/＞＜/property＞ ＜property name="transactionAttributeSource"＞ ＜value＞ com.test.UserManager.*r=PROPAGATION_REQUIRED ＜/value＞ ＜/property＞ ＜/bean＞ （3）为组件声明一个代理类：ProxyFactoryBean ＜bean id="userManager" class="org.springframework.aop.framework.ProxyFactoryBean"＞ ＜property name="proxyInterfaces"＞＜value＞com.test.UserManager＜/value＞＜/property＞ ＜property name="interceptorNames"＞ ＜list＞ ＜idref local="transactionInterceptor"/＞ ＜/list＞ ＜/property＞ ＜/bean＞ 使用TransactionProxyFactoryBean： ＜bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"＞ ＜property name="transactionManager"＞＜ref bean="transactionManager"/＞＜/property＞ ＜property name="target"＞＜ref local="userManagerTarget"/＞＜/property＞ ＜property name="transactionAttributes"＞ ＜props＞ ＜prop key="insert*"＞PROPAGATION_REQUIRED＜/prop＞ ＜prop key="update*"＞PROPAGATION_REQUIRED＜/prop＞ ＜prop key="*"＞PROPAGATION_REQUIRED,readOnly＜/prop＞ ＜/props＞ ＜/property＞ ＜/bean＞ TransactionProxyFactoryBean只是为组件的事务代理，如果我们要给组件添加一些业务方面的验证等，可以使用TransactionTemplate加拦截器方式，为组件添加多个拦截器，spring AOP中提供了三类Advice,即前增强，后增强，抛出异常时的增强，可以灵活使用。

DataSourceTransactionManager：事务管理器 对JDBC（Java Data Base Connectivity,java数据库连接）进行事务管理，在spring中是对JdbcTemplate进行事务管理 扩展： HibernateTransactionManager：是对Hibernate进行事务管理，当在spring中使用Hi...

在SpringSide 3 中，白衣提供的预先配置好的环境非常有利于用户进行快速开发，但是同时也会为扩展带来一些困难。最直接的例子就是关于在项目中使用多个数据源的问题，似乎 很难搞。在上一篇中，我探讨了SpringSide 3 中的数据访问层，在这一篇中，我立志要解决多数据源配置的难题，我的思路是这样的：第一步、测试能否配置多个DataSource第二步、测试能否配置多个SessionFactory第三步、测试能否配置多个TransactionManager第四步、测试能否使用多个TransactionManager，也就是看能否配置多个基本上到第四步就应该走不通了，因为Spring中似乎不能配置多个，而且@transactional注解也无法让用户选择具体使用哪个TransactionManager。也就是说，在SpringSide的应用中，不能让不同的数据源分别属于不同的事务管理器，多数据源只能使用分布式事务管理器，那么测试思路继续如下进行：第五步、测试能否配置JTATransactionManager如果到这一步，项目还能顺利在Tomcat中运行的话，我们就算大功告成了。但我总认为事情不会那么顺利，我总觉得JTATransactionManager需要应用服务器的支持，而且需要和JNDI配合使用，具体是不是这样，那只有等测试后才知道。如果被我不幸言中，那么进行下一步：第六步、更换Tomcat为GlassFish，更换JDBC的DataSource为JNDI查找的DataSource，然后配置JTATransactionManager下面测试开始，先假设场景，还是继续用上一篇中提到的简单的文章发布系统，假设该系统运行一段时间后非常火爆，单靠一台服务器已经无法支持巨大的用户数， 这时候，站长想到了把数据进行水平划分，于是，需要建立一个索引数据库，该索引数据库需保存每一篇文章的Subject及其内容所在的Web服务器，而每 一个Web服务器上运行的项目，需要同时访问索引数据库和内容数据库。所以，需要创建索引数据库，如下：[java] view plain copycreate database puretext_index; use puretext_index; create table articles( id int primary key auto_increment, subject varchar(256), webserver varchar(30) ); 第一步测试，配置多个DataSource，配置文件如下：application.properties：[java] view plain copyjdbc.urlContent=jdbc:mysql://localhost:3306/PureText useUnicode=true&characterEncoding=utf8 jdbc.urlIndex=jdbc:mysql://localhost:3306/PureText_Index useUnicode=true&characterEncoding=utf8

WEB-INFclassesapplicationContext-actions.xml中 name是 "logService" 的类没指定好。

spring中管理事务的配置方式除了@Transcational还有使用aop等，本文介绍@Transcational方式，但是推荐使用aop方式。因为如果有多个事务管理器的话，你在注解中还需要注明使用哪个事务管理器@Transactional("transactionManager1")。

不用疑虑了 是数据库连接的问题1、检查连接字符串，如端口，这些是否正确2、确定mysql服务开启成功3、在linux下也有这种情况出现注销/etc/my.cnf 文件中skipnetwork 这行

是dao里的，我们都是写一些操作数据库的接口dao，dao里面有add...的方法，在dao的实现类里进行具体操作！

表的主键有问题吧，违反唯一性，一般都是表的问题，表里的主键id是唯一的，你是不是有重复的id值

如果您使用此方法，则可以在测试结束之后回滚在测试过程中执行的任何更改。下面的过程说明了具体的做法：在使用 BEGIN TRANSACTION 和ROLLBACK TRANSACTION 的Transact-SQL 测试脚本中创建事务。为某个测试类中的单个测试方法创建一个事务。为给定测试类中的所有测试方法创建一个事务。系统必备组件对于本主题中的某些过程，运行单元测试的计算机必须正在运行 Distributed Transaction Coordinator 服务。有关更多信息，请参见本主题末尾的过程。使用Transact-SQL 创建事务使用Transact-SQL 创建事务在数据库单元测试设计器中打开单元测试。指定要创建事务的脚本类型。例如，可以指定预先测试、测试或后期测试。在Transact-SQL 编辑器中输入测试脚本。插入BEGIN TRANSACTION 和ROLLBACK TRANSACTION 语句，如下面的简单示例所示。此示例使用名为 OrderDetails 并包含 50 行数据的数据库表：BEGIN TRANSACTION TestTransaction UPDATE "OrderDetails" set Quantity = Quantity + 10 IF @@ROWCOUNT!=50 RAISERROR("Row count does not equal 50",16,1) ROLLBACK TRANSACTION TestTransaction注意在执行 COMMIT TRANSACTION 语句之后不能对事务进行回滚。有关ROLLBACK TRANSACTION 如何与存储过程和触发器一起使用的更多信息，请参见 Microsoft 网站上的 ROLLBACK TRANSACTION (Transact-SQL)。为单个测试方法创建事务在该示例中，在使用 TransactionScope 类型时，会使用环境事务。默认情况下，“执行连接”和“特权连接”将不使用环境事务，因为这些连接是在执行该方法之前创建的。SqlConnection 具有一个 EnlistTransaction 方法，该方法将活动连接与某个事务相关联。环境事务在创建之后会自行注册为当前的事务，您可以通过 Current 属性来访问它。在该示例中，环境事务在释放之后进行回滚。如果要提交在运行单元测试时进行的任何更改，则必须调用 Complete 方法。为单个测试方法创建事务在“解决方案资源管理器”中，右击测试项目中的“引用”节点，然后单击“添加引用”。将显示"添加引用"对话框。单击“.NET”选项卡。在程序集列表中，单击“System.Transactions”，然后单击“确定”。打开单元测试的 Visual Basic 或 C# 文件。包装预先测试、测试和后期测试操作，如下面的 Visual Basic 代码示例所示： <TestMethod()> _ Public Sub dbo_InsertTable1Test() Using ts as New System.Transactions.TransactionScope( System.Transactions.TransactionScopeOption.Required) ExecutionContext.Connection.EnlistTransaction(Transaction.Current) PrivilegedContext.Connection.EnlistTransaction(Transaction.Current) Dim testActions As DatabaseTestActions = Me.dbo_InsertTable1TestData "Execute the pre-test script " System.Diagnostics.Trace.WriteLineIf((Not (testActions.PretestAction) Is Nothing), "Executing pre-test script...") Dim pretestResults() As ExecutionResult = TestService.Execute(Me.PrivilegedContext, Me.PrivilegedContext, testActions.PretestAction) "Execute the test script System.Diagnostics.Trace.WriteLineIf((Not (testActions.TestAction) Is Nothing), "Executing test script...") Dim testResults() As ExecutionResult = TestService.Execute(ExecutionContext, Me.PrivilegedContext, testActions.TestAction) "Execute the post-test script " System.Diagnostics.Trace.WriteLineIf((Not (testActions.PosttestAction) Is Nothing), "Executing post-test script...") Dim posttestResults() As ExecutionResult = TestService.Execute(Me.PrivilegedContext, Me.PrivilegedContext, testActions.PosttestAction) "Because the transaction is not explicitly committed, it "is rolled back when the ambient transaction is "disposed. "To commit the transaction, remove the comment delimiter "from the following statement: "ts.Complete() End Sub Private dbo_InsertTable1TestData As DatabaseTestActions注意如果使用的是 Visual Basic，则除了 Imports Microsoft.VisualStudio.TestTools.UnitTesting、Imports Microsoft.VisualStudio.TeamSystem.Data.UnitTesting 和Imports Microsoft.VisualStudio.TeamSystem.Data.UnitTest.Conditions，还必须添加 Imports System.Transactions。如果使用的是 Visual C#，则除了 Microsoft.VisualStudio.TestTools、Microsoft.VisualStudio.TeamSystem.Data.UnitTesting 和 Microsoft.VisualStudio.TeamSystem.Data.UnitTesting.Conditions 的 using 语句，还必须添加 using System.Transactions。还必须在这些程序集中添加对项目的引用。为某个测试类中的所有测试方法创建一个事务为某个测试类中的所有测试方法创建一个事务打开单元测试的 Visual Basic 或 C# 文件。在TestInitialize 中创建事务，并在 TestCleanup 中释放它，如下面的 Visual C# 代码示例所示：TransactionScope _trans; [TestInitialize()] public void Init() { _trans = new TransactionScope(); base.InitializeTest(); } [TestCleanup()] public void Cleanup() { base.CleanupTest(); _trans.Dispose(); } [TestMethod()] public void TransactedTest() { DatabaseTestActions testActions = this.DatabaseTestMethod1Data; // Execute the pre-test script // System.Diagnostics.Trace.WriteLineIf((testActions.PretestAction != null), "Executing pre-test script..."); ExecutionResult[] pretestResults = TestService.Execute(this.PrivilegedContext, this.PrivilegedContext, testActions.PretestAction); // Execute the test script // System.Diagnostics.Trace.WriteLineIf((testActions.TestAction != null), "Executing test script..."); ExecutionResult[] testResults = TestService.Execute(this.ExecutionContext, this.PrivilegedContext, testActions.TestAction); // Execute the post-test script // System.Diagnostics.Trace.WriteLineIf((testActions.PosttestAction != null), "Executing post-test script..."); ExecutionResult[] posttestResults = TestService.Execute(this.PrivilegedContext, this.PrivilegedContext, testActions.PosttestAction); }启动Distributed Transaction Coordinator 服务本主题中的某些过程使用 System.Transactions 程序集内的类型。在按照这些过程操作之前，必须确保要运行单元测试的计算机上正在运行 Distributed Transaction Coordinator 服务。否则，测试将失败，并出现下面的错误消息：“测试方法 项目名称.测试名称.方法名称 引发异常: System.Data.SqlClient.SqlException: 服务器‘计算机名称"上的 MSDTC 不可用”。启动Distributed Transaction Coordinator 服务打开“控制面板”。在“控制面板”中打开“管理工具”。在“管理工具”中打开“服务”。在“服务”窗格中，右击 “Distributed Transaction Coordinator” 服务，再单击“启动”。该服务的状态应当更新为“已启动”。现在应当能够运行那些使用 System.Transactions 的单元测试。重要事项即使您启动了分布式事务处理控制器服务，仍然可能出现以下错误：System.Transactions.TransactionManagerCommunicationException: Network access for Distributed Transaction Manager (MSDTC) has been disabled. Please enable DTC for network access in the security configuration for MSDTC using the Component Services Administrative tool. ---> System.Runtime.InteropServices.COMException: The transaction manager has disabled its support for remote/network transactions. (Exception from HRESULT: 0x8004D024)。如果出现此错误，您必须为网络访问配置分布式事务处理控制器。有关更多信息，请参见启用网络 DTC 访问 。

第一步、测试能否配置多个DataSource第二步、测试能否配置多个SessionFactory第三步、测试能否配置多个TransactionManager第四步、测试能否使用多个TransactionManager，也就是看能否配置多个<tx:annotation-driven/>第五步、测试能否配置JTATransactionManager第六步、更换Tomcat为GlassFish，更换JDBC的DataSource为JNDI查找的DataSource，然后配置JTATransactionManager

你的dataSource在一个地方重复注入了看你的这个地方，你的切面定义在全局。所以这个地方有问题，把下面这段先注释掉，或者把切面精确去找问题。（和上面注入冲突了） <aop:config> <aop:pointcut id="serviceOperation" expression="execution(* *.*(..))" /> <aop:advisor advice-ref="transactionAdvice" pointcut-ref="serviceOperation" /> </aop:config>

数据库配置方面用问题。检查你的连接串，用户名，密码是否正确，并确认是否有空格

可以，Spring的事务处理能力是最综合完整的，对编程式、声明式均进行了支持，而且可以在不使用应用服务器的情况下兼容应用服务器事务。下面的是一个分布式的声明事务，访问多个数据源的配置：<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans default-autowire="byName"><!-- Configurer that replaces ${...} placeholders with values from a properties file --> <!-- (in this case, JDBC-related settings for the dataSource definition below) --> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:spring/jdbc.properties</value> </list> </property> </bean> <bean id="dataSourceMysql" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close"> <property name="uniqueResourceName" value="${mysql.uniqueResourceName}" /> <property name="xaDataSourceClassName" value="${mysql.xaDataSourceClassName}" /> <property name="xaProperties"> <props> <prop key="user">${mysql.user}</prop> <prop key="password">${mysql.password}</prop> <prop key="URL">${mysql.url}</prop> </props> </property> <property name="poolSize" value="${mysql.poolSize}" /> </bean> <bean id="dataSourceOracle" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close"> <property name="uniqueResourceName" value="${oracle.uniqueResourceName}" /> <property name="xaDataSourceClassName" value="${oracle.xaDataSourceClassName}" /> <property name="xaProperties"> <props> <prop key="user">${oracle.user}</prop> <prop key="password">${oracle.password}</prop> <prop key="URL">${oracle.url}</prop> </props> </property> <property name="poolSize" value="${oracle.poolSize}" /> </bean> <!-- Construct Atomikos UserTransactionManager, needed to configure Spring --> <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close"> <!-- when close is called, should we force transactions to terminate or not? --> <property name="forceShutdown" value="${transactionManager.forceShutdown}" /> </bean> <!-- Also use Atomikos UserTransactionImp, needed to configure Spring --> <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp"> <property name="transactionTimeout" value="${transactionManager.transactionTimeout}" /> </bean> <!-- Configure the Spring framework to use JTA transactions from Atomikos --> <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"> <property name="transactionManager"> <ref bean="atomikosTransactionManager" /> </property> <property name="userTransaction"> <ref bean="atomikosUserTransaction" /> </property> </bean> <bean id="txManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true"> <property name="transactionManager"> <ref bean="transactionManager" /> </property> <property name="transactionAttributes"> <props> <prop key="save*">PROPAGATION_REQUIRED, +AuaException</prop> </props> </property> </bean> <bean id="studentOracleDao" class="com.aua.dao.oracle.StudentDao" /> <bean id="studentMysqlDao" class="com.aua.dao.mysql.StudentDao" /> <bean id="studentService" parent="txManager"> <property name="target"> <bean class="com.aua.service.impl.StudentService" /> </property> </bean></beans>

1.使用注解的方式<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"><!-- 使用annotation定义数据库事务，这样可以在类或方法中直接使用@Transactional注解来声明事务 --> <tx:annotation-driven transaction-manager="transactionManager" /></beans> 2.使用事务管理器来管理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean> <aop:config> <!-- 切入点指明了在执行com.zxt.service包中的所有方法时产生事务拦截操作 --> <aop:pointcut id="daoMethods" expression="execution(* com.zxt.service.*.*(..))" /> <!-- 定义了将采用何种拦截操作，这里引用到 txAdvice --> <aop:advisor advice-ref="txAdvice" pointcut-ref="daoMethods" /> </aop:config> <!-- 事务通知操作，使用的事务管理器引用自transactionManager --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <!-- 指定哪些方法需要加入事务 --> <tx:method name="save*" propagation="REQUIRED" /> <tx:method name="delete*" propagation="REQUIRED" /> <tx:method name="update*" propagation="REQUIRED" /> <!-- read-only="true"：其余方法只读格式，加强其安全性 --> <tx:method name="*" read-only="true" propagation="NOT_SUPPORTED" /> </tx:attributes> </tx:advice> </beans>

与数据库的连接被关闭了,检查一下数据库连接的稳定性

你的txAdvice没有配置正确哦，需要加上一句：rollback-for="Exception"，表示遇到异常就回滚

1、 Propagation 　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。 2、 Isolation Level(事务隔离等级):1、Serializable：最严格的级别，事务串行执行，资源消耗最大；2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。4、Read Uncommitted：保证了读取过程中不会读取到非法数据。隔离级别在于处理多事务的并发问题。我们知道并行可以提高数据库的吞吐量和效率，但是并不是所有的并发事务都可以并发运行，这需要查看数据库教材的可串行化条件判断了。