问答首页 → 移动开发技术
0 0

SpringMVC 整合 JPA时出现了好像是事务无法提交的问题15

最近在做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体系的异常 -->
	<bean
		class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

	<!-- 数据源配置 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url"
			value="jdbc:mysql://localhost:3306/smhj?useUnicode=true&amp;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" />
	</bean>

	<!-- 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">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
	</bean>

	<!-- 特定的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" />
	</bean>

</beans>


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">
			<list>
				<bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter" />
				<bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter" />
				<bean class="org.springframework.http.converter.StringHttpMessageConverter" >
					<property name="supportedMediaTypes">
						<list>
							<value>text/html;charset=utf-8</value>
							<value>text/xml</value>
							<value>text/plain</value>
						</list>
					</property>
				</bean>
				<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
			</list>
		</property>
	</bean>
	
	<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.web.multipart.commons.CommonsMultipartResolver">
		<property name="defaultEncoding" value="utf-8" />
		<property name="maxUploadSize" value="10485760000" />
		<property name="maxInMemorySize" value="40960" />
	</bean>
	
</beans>


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.entity;

import java.io.Serializable;
import java.sql.Timestamp;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="bd_id")
public class Identity implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue
	private long id;
	
	@Column(length=100)
	private String code;
	
	private Long value;
	
	@Column(length = 10)  
    private String prefix;  
  
    @Column(length = 10)  
    private String suffix;  
  
    @Column(length = 255)  
    private String description;  
  
    private Integer length;  
  
    @Column(length = 30)  
    private String creator;  
  
    @Column(name = "create_date")  
    private Timestamp createDate;  
  
    @Column(length = 30)  
    private String modifier;  
  
    @Column(name = "modify_Date")  
    private Timestamp modifyDate;
    
    private Boolean dr;

	public Boolean getDr() {
		return dr;
	}

	public void setDr(Boolean dr) {
		this.dr = dr;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public Long getValue() {
		return value;
	}

	public void setValue(Long value) {
		this.value = value;
	}

	public String getPrefix() {
		return prefix;
	}

	public void setPrefix(String prefix) {
		this.prefix = prefix;
	}

	public String getSuffix() {
		return suffix;
	}

	public void setSuffix(String suffix) {
		this.suffix = suffix;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public Integer getLength() {
		return length;
	}

	public void setLength(Integer length) {
		this.length = length;
	}

	public String getCreator() {
		return creator;
	}

	public void setCreator(String creator) {
		this.creator = creator;
	}

	public Timestamp getCreateDate() {
		return createDate;
	}

	public void setCreateDate(Timestamp createDate) {
		this.createDate = createDate;
	}

	public String getModifier() {
		return modifier;
	}

	public void setModifier(String modifier) {
		this.modifier = modifier;
	}

	public Timestamp getModifyDate() {
		return modifyDate;
	}

	public void setModifyDate(Timestamp modifyDate) {
		this.modifyDate = modifyDate;
	}

	public static long getSerialversionuid() {
		return serialVersionUID;
	}

}


IdentityDaoImpl 
package com.howlink.dao;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.howlink.entity.Identity;

@Repository("identityDaoImpl")
public class IdentityDaoImpl implements IIdentityDao{
	
	@PersistenceContext(unitName="howlink_unit")  
    private EntityManager em;  
  
    @Transactional(propagation=Propagation.REQUIRED)
    public Identity create(Identity data) {  
    	if(em!=null){
    		System.out.println("hello");
    	}
        em.persist(data);
        return 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);  
        return data;  
    }  
    @Transactional(propagation = Propagation.REQUIRED)
    public void delete(String id) {  
        em.remove(retriver(id));  
    }
	public EntityManager getEm() {
		return em;
	}
	public void setEm(EntityManager em) {
		this.em = em;
	}  
    
    
}


IdentityController 

package com.howlink.controller;

import java.sql.Timestamp;
import java.util.Calendar;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.howlink.dao.IIdentityDao;
import com.howlink.entity.Identity;

@Controller  
@RequestMapping("/identity")
public class IdentityController {
	
	@Resource(name="identityDaoImpl") 
    private IIdentityDao dao;  
  
    @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 returnData;  
    }  
  
    @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 returnData;  
    }  
  
    @RequestMapping("/delete")  
    public void delete(@RequestParam String id) {  
        dao.delete(id);  
    }  
}


以上是代码和配置文件：
在执行IdentityDaoImpl 里的create方法的时候没有报任何错误，但是就是不能把数据持久化到数据库

我怀疑是事务没有提交 但是不知道要怎么搞  希望有做过类似整合并成功的同志看看  谢谢


企业应用 
2014年7月16日 12:16

4个答案 按时间排序 按投票排序

0 0

在persistence.xml文件中，将下面的
<persistence-unit name="howlink_unit" 
        transaction-type="RESOURCE_LOCAL">
改成
<persistence-unit name="howlink_unit" 
        transaction-type="JPA">

RESOURCE_LOCAL：表示事物需要手动将entityManager的事物打开、提交、关闭。
JPA：是希望将事物交给Spring容器去管理，不需要我们手动去管理。
希望对你有帮助！

2017年4月23日 21:21
0 0

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> 

2014年7月17日 16:41
0 0

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无意中看到你的问题了，我就调试了一下，祝你工作顺利。

2014年7月17日 10:47
0 0

http://www.iteye.com/problems/102304

2014年7月16日 12:53

相关推荐

    springmvc+jpa(hibernate实现)+spring整合实例

    工作用了springmvc+jpa+spring这么长时间，这段时间正好有点时间就想整合一下，但在整合过程中遇到了各种问题，上网查了很多资料但讲的都很模糊或者是没有注释，在我一步一步的试验中终于整合成功了，做为我自已以后...

    Spring SpringMVC Jpa整合Demo

    在JavaEE开发中，Spring、SpringMVC和JPA是三个非常重要的框架，它们的整合应用可以极大地提高开发效率和代码质量。这个"Spring SpringMVC Jpa整合Demo"就是一个典型的例子，它展示了如何将这三个框架协同工作，构建...

    spring+springMVC+jpa+hibernate框架整合

    在IT领域，构建高效、可扩展的Web应用是至关重要的，而"spring+springMVC+jpa+hibernate框架整合"就是一个常见的解决方案。这个整合涉及到四个关键的技术栈：Spring框架、SpringMVC、JPA（Java Persistence API）...

    springmvc+jpa 例子

    在Spring MVC应用中整合JPA，可以实现高效的数据库操作。以下是一些关键步骤： 1. **配置JPA**：在Spring配置文件中，添加JPA的供应商（如Hibernate），设置数据源、实体扫描路径等。 2. **配置DataSource**：定义...

    springMvc data jpa example

    这里可能包含数据源配置、JPA 配置（如实体管理工厂、事务管理器等）以及 Spring MVC 的视图解析器、处理器映射器和适配器等。 2. **实体类（Entity）**：这些是与数据库表对应的 Java 类，通常包含 JPA 注解，如 `...

    maven构建项目，整合springmvc jpa

    在IT行业中，构建Java应用程序时，我们经常使用Maven作为项目管理工具，SpringMVC作为Web层框架，而JPA（Java Persistence API）则作为持久层解决方案。这三者结合可以构建出高效、可维护的现代企业级应用。现在，让...

    spring+springMVC+maven+jpa框架搭建

    将这些框架结合在一起搭建项目时，首先需要在Maven的pom.xml文件中添加Spring、SpringMVC和JPA的相关依赖。然后，配置Spring的ApplicationContext.xml，定义Bean，包括数据源、实体管理工厂、事务管理器等。接着，为...

    spring+springmvc+jpa(hibernate)框架整合

    同时，SpringMVC的异常处理机制可以帮助我们优雅地处理程序运行时可能出现的问题。 总的来说，Spring+SpringMVC+JPA（Hibernate）的整合为Java Web应用开发提供了强大的支持，使得我们可以更加专注于业务逻辑，而...

    SpringMVC４＋JPA Demo

    本Demo将详细介绍如何在SpringMVC 4项目中整合JPA，实现高效的数据操作。 首先，让我们理解这两个核心概念： 1. **SpringMVC 4**：SpringMVC是Spring框架的一部分，提供了一个用于构建Web应用程序的模型-视图-控制...

    Springmvc+JPA(Hibernate4)+redis+activemq

    综上所述，"Springmvc+JPA(Hibernate4)+redis+activemq"的组合为开发者提供了一套强大、全面的工具集，可用于构建高度可扩展、高性能的现代Web应用。通过熟练掌握这些技术，开发者能够构建出更加健壮和灵活的应用...

    spring3+springmvc+jpa+hibernate

    Spring3、SpringMVC、JPA（Java Persistence API）和Hibernate是Java开发中常见的四大框架，它们在企业级应用开发中扮演着至关重要的角色。这个项目集成了这些框架，为开发者提供了一个快速搭建Web应用程序的基础...

    SpringMVC+JPA+Freeemarker 纯javaConfig，无xml配置

    6. **事务管理**：在Java Config中，Spring的事务管理可以通过`PlatformTransactionManager`的实现来配置，如`JpaTransactionManager`，它负责协调数据库事务。 7. **Spring Boot**：虽然标题未提及Spring Boot，但...

    springmvc spring hibernate jpa maven 整合

    这个项目"springmvc spring hibernate jpa maven 整合"就是这样一个例子，它整合了四个关键的技术组件：Spring MVC、Spring、Hibernate和JPA，以及依赖管理工具Maven。让我们详细探讨这些技术及其在项目中的作用。 ...

    spring+springmvc+jpa+jsp 练习demo项目源码

    【标题】：“Spring+SpringMVC+JPA+JSP 练习demo项目源码”是一个结合了四个关键Java技术的实践项目，旨在帮助开发者掌握它们的集成与应用。 【描述】：该项目的核心是通过Spring框架（包括Spring Core和Spring MVC...

    Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA

    在现代Java Web开发中，"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合，被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM"，其中"M"代表Maven，"S"代表Spring，包括Spring核心...

    Spring+SpringMVC+JPA+Hibernate搭建

    12. 将SpringMVC整合到已经搭建好的框架中，需要创建一个annotated-mvc-servlet.xml文件，配置web层的组件以及视图解析器等。 13. 配置控制器（Controller）以处理Web层的请求，并将视图解析器配置到Spring MVC配置...

    用maven构建SpringMVC+JPA+Hibernate+Hsql+jetty的web项目

    【标题】"用maven构建SpringMVC+JPA+Hibernate+Hsql+jetty的web项目"涉及了多个核心的Java Web开发技术，这里我们将深入探讨这些技术以及如何将它们整合到一起。 1. Maven：Maven是Apache的一个开源项目，它是一个...

    springmvc+springjpa+hibernate整合简例

    总结来说，"springmvc+springjpa+hibernate整合简例"涉及到的主要知识点包括： 1. SpringMVC的请求处理流程和配置。 2. SpringJPA的使用，包括实体和数据访问接口的定义。 3. Hibernate作为JPA提供者的配置和特性...

    SpringMVC+Spring+Spring-Data-JPA整合-完整Demo

    本项目“SpringMVC+Spring+Spring-Data-JPA整合-完整Demo”旨在提供一个全面的示例，展示如何将SpringMVC、Spring和Spring Data JPA这三个关键模块集成到一个应用程序中。下面，我们将深入探讨这些技术及其整合的...

    spring+springmvc+hibernate+jpa搭建

    在IT行业中，构建一个基于Spring、SpringMVC、Hibernate和JPA的开发环境是常见的任务，这四个组件都是Java企业级应用开发中的重要工具。让我们深入探讨这些技术以及如何将它们整合在一起搭建一个完整的开发环境。 *...

Magicbox
Ask-but
我的问答 FAQ | 勋章

相关推荐

已解决问题

未解决问题

排行榜

Global site tag (gtag.js) - Google Analytics