在用JPA实现对象持久化的时候 出现以下异常 求解答 - Java Web开发当前位置:& &&&在用JPA实现对象持久化的时候 出现以下异常 求解答在用JPA实现对象持久化的时候 出现以下异常 求解答&&网友分享于：&&浏览：26次在用JPA实现对象持久化的时候 出现以下错误 求解答严重:&Servlet.service()&for&servlet&dispatcher&threw&exception
:&You&have&an&error&in&your&SQL&&check&the&manual&that&corresponds&to&your&MySQL&server&version&for&the&right&syntax&to&use&near&'order&(uuid,&startTime,&content,&money,&orderTime,&endTime,&serviceArea,&company'&at&line&1
at&sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native&Method)
at&sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
at&sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at&java.lang.reflect.Constructor.newInstance(Constructor.java:526)
at&com.mysql.jdbc.Util.handleNewInstance(Util.java:406)
at&com.mysql.jdbc.Util.getInstance(Util.java:381)
at&.create(SQLError.java:1030)
at&com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
at&com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3491)
at&com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3423)
at&com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1936)
at&com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2060)
at&com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2542)
at&com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1734)
at&com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2019)
at&com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1937)
at&com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1922)
at&org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor.executeDirectNoSelect(DatabaseAccessor.java:791)
at&org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor.executeNoSelect(DatabaseAccessor.java:866)
at&org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor.basicExecuteCall(DatabaseAccessor.java:586)
at&org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor.executeCall(DatabaseAccessor.java:529)
at&org.eclipse.persistence.internal.sessions.AbstractSession.executeCall(AbstractSession.java:914)
at&org.eclipse.persistence.internal.queries.DatasourceCallQueryMechanism.executeCall(DatasourceCallQueryMechanism.java:205)
at&org.eclipse.persistence.internal.queries.DatasourceCallQueryMechanism.executeCall(DatasourceCallQueryMechanism.java:191)
at&org.eclipse.persistence.internal.queries.DatasourceCallQueryMechanism.insertObject(DatasourceCallQueryMechanism.java:334)
at&org.eclipse.persistence.internal.queries.StatementQueryMechanism.insertObject(StatementQueryMechanism.java:162)
at&org.eclipse.persistence.internal.queries.StatementQueryMechanism.insertObject(StatementQueryMechanism.java:177)
at&org.eclipse.persistence.internal.queries.DatabaseQueryMechanism.insertObjectForWrite(DatabaseQueryMechanism.java:461)
at&org.eclipse.persistence.queries.InsertObjectQuery.executeCommit(InsertObjectQuery.java:80)
at&org.eclipse.persistence.queries.InsertObjectQuery.executeCommitWithChangeSet(InsertObjectQuery.java:90)
at&org.eclipse.persistence.internal.queries.DatabaseQueryMechanism.executeWriteWithChangeSet(DatabaseQueryMechanism.java:286)
at&org.eclipse.persistence.queries.WriteObjectQuery.executeDatabaseQuery(WriteObjectQuery.java:58)
at&org.eclipse.persistence.queries.DatabaseQuery.execute(DatabaseQuery.java:675)
at&org.eclipse.persistence.queries.DatabaseQuery.executeInUnitOfWork(DatabaseQuery.java:589)
at&org.eclipse.persistence.queries.ObjectLevelModifyQuery.executeInUnitOfWorkObjectLevelModifyQuery(ObjectLevelModifyQuery.java:109)
at&org.eclipse.persistence.queries.ObjectLevelModifyQuery.executeInUnitOfWork(ObjectLevelModifyQuery.java:86)
at&org.eclipse.persistence.internal.sessions.UnitOfWorkImpl.internalExecuteQuery(UnitOfWorkImpl.java:2863)
at&org.eclipse.persistence.internal.sessions.AbstractSession.executeQuery(AbstractSession.java:1225)
at&org.eclipse.persistence.internal.sessions.AbstractSession.executeQuery(AbstractSession.java:1207)
at&org.eclipse.persistence.internal.sessions.AbstractSession.executeQuery(AbstractSession.java:1167)
at&org.eclipse.persistence.mitNewObjectsForClassWithChangeSet(CommitManager.java:197)
at&org.eclipse.persistence.mitAllObjectsWithChangeSet(CommitManager.java:103)
at&org.eclipse.persistence.internal.sessions.AbstractSession.writeAllObjectsWithChangeSet(AbstractSession.java:3260)
at&org.eclipse.persistence.internal.mitToDatabase(UnitOfWorkImpl.java:1405)
at&org.eclipse.persistence.internal.mitToDatabase(RepeatableWriteUnitOfWork.java:547)
at&org.eclipse.persistence.internal.mitToDatabaseWithChangeSet(UnitOfWorkImpl.java:1510)
at&org.eclipse.persistence.internal.mitRootUnitOfWork(RepeatableWriteUnitOfWork.java:200)
at&org.eclipse.persistence.internal.mitAndResume(UnitOfWorkImpl.java:1131)
at&org.eclipse.persistence.internal.jpa.mitInternal(EntityTransactionImpl.java:84)
at&org.eclipse.persistence.internal.jpa.mit(EntityTransactionImpl.java:63)
at&org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:467) 共&2&页:
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有JPA，带你入门
JPA，带你入门
编辑：www.fx114.net
本篇文章主要介绍了"JPA，带你入门"，主要涉及到JPA，带你入门方面的内容，对于JPA，带你入门感兴趣的同学可以参考一下。
&&&&& JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA
吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某
一个ORM框架。
为什么要使用JAP?
&&& 在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。
&&& ORM 是Object-Relation-Mapping，即对象关系影射技术，是对象持久化的核心。ORM是对JDBC的封装，从而解决
了JDBC的各种存在问题：
a) 繁琐的代码问题
&& 用JDBC的API编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐、累赘，容易出错。
例如：PreparedStatement pstmt=con.prepareStatment(&insert into account value(?,?,?,?,?,?,?,?,?)&);
ORM则建立了Java对象与数据库对象之间的影射关系，程序员不需要编写复杂的SQL语句，直接操作Java对象即可，从
而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
b) 数据库对象连接问题
&& 关系数据对象之间，存在各种关系，包括1对1、1对多、多对1、多对多、级联等。在数据库对象更新的时候，采
用JDBC编程，必须十分小心处理这些关系，以保证维持这些关系不会出现错误，而这个过程是一个很费时费力的过程。
&& ORM建立Java对象与数据库对象关系影射的同时，也自动根据数据库对象之间的关系创建Java对象的关系，并且提
供了维持这些关系完整、有效的机制。
c) 系统架构问题
&& JDBC属于数据访问层，但是使用JDBC编程时，必须知道后台是用什么数据库、有哪些表、各个表有有哪些字段、
各个字段的类型是什么、表与表之间什么关系、创建了什么索引等等与后台数据库相关的详细信息。
使用ORM技术，可以将数据库层完全隐蔽，呈献给程序员的只有Java的对象，程序员只需要根据业务逻辑的需要调用
Java对象的Getter和 Setter方法，即可实现对后台数据库的操作，程序员不必知道后台采用什么数据库、有哪些
表、有什么字段、表与表之间有什么关系。
d) 性能问题
&& 采用JDBC编程，在很多时候存在效率低下的问题。
pstmt =conn.prepareStatement(&insert into user_info values(?,?)&);
&&&&&& for (int i=0; i&1000; i++) {
&&&&&&&&& pstmt.setInt(1,i);
&&&&&&&&& pstmt.setString(2,&User&+i.toString());
&&&&&&&&& pstmt.executeUpdate();
&& 以上程序将向后台数据库发送1000次SQL语句执行请求，运行效率较低。
&& 采用ORM技术，ORM框架将根据具体数据库操作需要，会自动延迟向后台数据库发送SQL请求，ORM也可以根据实际
情况，将数据库访问操作合成，尽量减少不必要的数据库操作请求。
JPA是目前比较流行的一种ORM技术之一，所以他拥有ORM技术的各种特点，当然他还有自己的一些优势：
1 标准化　
&　JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的
访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2 对容器级特性的支持　
&& JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发
挥更大的作用。
3 简单易用，集成方便　
&& JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约
束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则
和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器
4 可媲美JDBC的查询能力　　
&& JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate
HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对
实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、
HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
5 支持面向对象的高级特性　
&& JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最
大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
一、不得利用本站危害国家安全、泄露国家秘密，不得侵犯国家社会集体的和公民的合法权益，不得利用本站制作、复制和传播不法有害信息！
二、互相尊重，对自己的言论和行为负责。
本文标题：
本页链接：SpringMVC 整合 JPA时出现了好像是事务无法提交的问题 - ITeye问答
最近在做Springmvc 和JPA 的整合& 整合完之后好像出现了事务无法提交的问题
因为在获取entityManager的时候是可以获取到的 程序执行下来控制台也没有报错
但是就是无法把数据持久化到数据库当中...
猜测可能是由于Spring事务没有提交
applicationContext.xml
&?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: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/tx
http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.1.xsd"&
&context:annotation-config /&
&!-- 不扫描Controller注解 --&
&context:component-scan base-package="com.howlink" /&
&!-- &context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"
/& &/context:component-scan& --&
&tx:annotation-driven transaction-manager="transactionManager" /&
&!-- 对标注@Repository的类经行增强，将EntityManager异常转换为SpringDAO体系的异常 --&
class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" /&
&!-- 数据源配置 --&
&bean id="dataSource" class="mons.dbcp.BasicDataSource"&
&property name="driverClassName" value="com.mysql.jdbc.Driver"&&/property&
&property name="url"
value="jdbc:mysql://localhost:3306/smhj?useUnicode=true&characterEncoding=utf-8"&&/property&
&property name="username" value="root"&&/property&
&property name="password" value="admin"&&/property&
&property name="maxActive" value="20"&&/property&
&property name="maxIdle" value="10"&&/property&
&property name="minIdle" value="3"&&/property&
&property name="initialSize" value="3"&&/property&
&property name="defaultAutoCommit" value="true" /&
&!-- 每timeBetweenEvictionRunsMillis毫秒,检查一次连接池中的空闲连接,把空闲时间超过minEvictableIdleTimeMillis
毫秒的连接断开,知道连接池中的连接数达到minIdle为止! --&
&property name="timeBetweenEvictionRunsMillis" value="3600000" /&
&property name="minEvictableIdleTimeMillis" value="3600000" /&
&!-- JPA 实体管理工厂 --&
&bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"&
&property name="dataSource" ref="dataSource" /&
&property name="persistenceXmlLocation" value="classpath:persistence.xml"&&/property&
&property name="persistenceUnitName" value="howlink_unit"&&/property&
&property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" /&
&property name="jpaProperties"&
&prop key="hibernate.dialect"&org.hibernate.dialect.MySQL5Dialect&/prop&
&prop key="hibernate.show_sql"&true&/prop&
&prop key="hibernate.hbm2ddl.auto"&update&/prop&
&/property&
&!-- 特定的JPA实现细节 --&
&bean id="hibernateJpaVendorAdapter"
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" /&
&!-- JPA 事务管理 --&
&bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"&
&property name="dataSource" ref="dataSource" /&
&property name="entityManagerFactory" ref="entityManagerFactory" /&
spring-mvc.xml
&?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:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.1.xsd"&
&!-- 默认的注解映射的支持 --&
&mvc:annotation-driven /&
&context:component-scan base-package="com.howlink.*" &
&context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" /&
&/context:component-scan&
&!-- 配置可访问静态资源 --&
&mvc:default-servlet-handler /&
&!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 --&
&bean id="defaultAnnotationHandlerMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /&
&bean id="annotationMethodHandlerAdapter"
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"&
&property name="messageConverters"&
&bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter" /&
&bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter" /&
&bean class="org.springframework.http.converter.StringHttpMessageConverter" &
&property name="supportedMediaTypes"&
&value&text/charset=utf-8&/value&
&value&text/xml&/value&
&value&text/plain&/value&
&/property&
&bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" /&
&/property&
&bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"&
&property name="prefix" value="/" /&
&property name="suffix" value=".jsp" /&
&/bean&&!-- 配置视图解析器 --&
&!-- 配置文件上传解析器 --&
&bean id="multipartResolver"
class="org.springframework.monsMultipartResolver"&
&property name="defaultEncoding" value="utf-8" /&
&property name="maxUploadSize" value="" /&
&property name="maxInMemorySize" value="40960" /&
persistence.xml
&?xml version="1.0" encoding="UTF-8"?&
&persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"&
&persistence-unit name="howlink_unit"
transaction-type="RESOURCE_LOCAL"&
&/persistence-unit&
&/persistence&
实体类 Identity
package com.howlink.
import java.io.S
import java.sql.T
import javax.persistence.C
import javax.persistence.E
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.T
@Table(name="bd_id")
public class Identity implements Serializable{
private static final long serialVersionUID = 1L;
@GeneratedValue
@Column(length=100)
@Column(length = 10)
@Column(length = 10)
@Column(length = 255)
@Column(length = 30)
@Column(name = "create_date")
private Timestamp createD
@Column(length = 30)
@Column(name = "modify_Date")
private Timestamp modifyD
public Boolean getDr() {
public void setDr(Boolean dr) {
public long getId() {
public void setId(long id) {
public String getCode() {
public void setCode(String code) {
this.code =
public Long getValue() {
public void setValue(Long value) {
this.value =
public String getPrefix() {
public void setPrefix(String prefix) {
this.prefix =
public String getSuffix() {
public void setSuffix(String suffix) {
this.suffix =
public String getDescription() {
public void setDescription(String description) {
this.description =
public Integer getLength() {
public void setLength(Integer length) {
this.length =
public String getCreator() {
public void setCreator(String creator) {
this.creator =
public Timestamp getCreateDate() {
return createD
public void setCreateDate(Timestamp createDate) {
this.createDate = createD
public String getModifier() {
public void setModifier(String modifier) {
this.modifier =
public Timestamp getModifyDate() {
return modifyD
public void setModifyDate(Timestamp modifyDate) {
this.modifyDate = modifyD
public static long getSerialversionuid() {
return serialVersionUID;
IdentityDaoImpl
package com.howlink.
import javax.persistence.EntityM
import javax.persistence.PersistenceC
import org.springframework.stereotype.R
import org.springframework.transaction.annotation.P
import org.springframework.transaction.annotation.T
import com.howlink.entity.I
@Repository("identityDaoImpl")
public class IdentityDaoImpl implements IIdentityDao{
@PersistenceContext(unitName="howlink_unit")
private EntityM
@Transactional(propagation=Propagation.REQUIRED)
public Identity create(Identity data) {
if(em!=null){
System.out.println("hello");
em.persist(data);
@Transactional(propagation = Propagation.REQUIRED)
public Identity retriver(String id) {
Long pk = Long.valueOf(id);
return em.find(Identity.class, pk);
@Transactional(propagation = Propagation.REQUIRED)
public Identity update(Identity data) {
em.merge(data);
@Transactional(propagation = Propagation.REQUIRED)
public void delete(String id) {
em.remove(retriver(id));
public EntityManager getEm() {
public void setEm(EntityManager em) {
IdentityController
package com.howlink.
import java.sql.T
import java.util.C
import javax.annotation.R
import org.springframework.stereotype.C
import org.springframework.web.bind.annotation.RequestM
import org.springframework.web.bind.annotation.RequestP
import org.springframework.web.bind.annotation.ResponseB
import com.howlink.dao.IIdentityD
import com.howlink.entity.I
@Controller
@RequestMapping("/identity")
public class IdentityController {
@Resource(name="identityDaoImpl")
private IIdentityD
@RequestMapping("retriver")
@ResponseBody
public Identity retriver(@RequestParam String id)
return dao.retriver(id);
@RequestMapping("/create")
@ResponseBody
public Identity create() {
int i = 1;
Identity data = new Identity();
data.setCode("code" + i);
Calendar c = Calendar.getInstance();
data.setCreateDate(new Timestamp(c.getTime().getTime()));
data.setCreator("creator" + i);
data.setDescription("description" + i);
data.setDr(false);
// data.setId("id" + Integer.toString(i));
data.setLength(30);
data.setModifier("modifier" + i);
data.setModifyDate(new Timestamp(c.getTime().getTime()));
data.setPrefix("prefix");
data.setSuffix("suffix");
data.setValue(0L);
Identity returnData = dao.create(data);
return returnD
@RequestMapping("/update")
@ResponseBody
public Identity update()
int i = 1;
Identity data = new Identity();
data.setCode("1");
Calendar c = Calendar.getInstance();
data.setCreateDate(new Timestamp(c.getTime().getTime()));
data.setCreator("creator" + i);
data.setDescription("description" + i);
data.setDr(false);
// data.setId("id" + Integer.toString(i));
data.setLength(30);
data.setModifier("modifier" + i);
data.setModifyDate(new Timestamp(c.getTime().getTime()));
data.setPrefix("prefix");
data.setSuffix("suffix");
data.setValue(0L);
Identity returnData = dao.update(data);
return returnD
@RequestMapping("/delete")
public void delete(@RequestParam String id) {
dao.delete(id);
以上是代码和配置文件：
在执行IdentityDaoImpl 里的create方法的时候没有报任何错误，但是就是不能把数据持久化到数据库
我怀疑是事务没有提交 但是不知道要怎么搞& 希望有做过类似整合并成功的同志看看& 谢谢
在persistence.xml文件中，将下面的
&persistence-unit name="howlink_unit"&
&&&&&&& transaction-type="RESOURCE_LOCAL"&
改成
&persistence-unit name="howlink_unit"&
&&&&&&& transaction-type="JPA"&
RESOURCE_LOCAL：表示事物需要手动将entityManager的事物打开、提交、关闭。
JPA：是希望将事物交给Spring容器去管理，不需要我们手动去管理。
希望对你有帮助！
spring-servlet.xml扫描包那句配置错误，等于所有的bean被重复扫描了。
改为这样：&context:component-scan base-package="com.howlink" use-default-filters="false"&&
&&&&&&& &context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" /&&
&&& &/context:component-scan&&
applicationContext.xml 中添加 context:component-scan 中 放开 context:exclude-filter 注释；
dao 前面添加 @Transactional 注解；
我是基于类创建的代理，所以我的 applicationContext.xml 中这样配置：&tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /& ， 你是基于接口创建代理，可以不用配置，默认就是false；
spring-mvc.xml 中 没改什么东西，这个问题不是因为和jpa 整合才出现的，就是使用注解注入和注解事物配置出现的。希望能帮到你，因为我最近在用openjpa无意中看到你的问题了，我就调试了一下，祝你工作顺利。
已解决问题
未解决问题