问答首页 → Java企业应用
0 0

Spring集成Hibernate，使用JPA注解方式，新增数据无法提交0

环境：

spring 3.1

hibernate 4.2.8 final 

mysql 5.6

问题描述：

调用controller的查询方法，可以正常返回数据

调用controller的创建方法，即：新增数据，控制台打印出了读取和修改序号表的sql，但是没有打印插入数据的sql，数据库表中也没有新增数据。

怀疑是spring控制的事务没有提交，但是排查了两三天，从网上找了各种方法，都没有解决问题。

请各位大侠拉小弟一把，实在是找不到事务为什么没有提交。

 

web.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">

	<!-- 欢迎界面 -->
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>

	<!-- spring框架 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 上下文配置 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/applicationContext.xml,
			/WEB-INF/config/**/*.xml
		</param-value>
	</context-param>


	<!-- spring mvc -->
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<!-- 拦截所有url -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<!-- 回话有效期30分钟 -->
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>

	<!-- log4j日志 -->
	<listener>
		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>

	<!-- log4j日志配置 -->
	<context-param>
		<param-name>log4jConfigLocation</param-name>
		<param-value>/WEB-INF/properties/log4j.properties</param-value>
	</context-param>



</web-app>

 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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 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/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/mvc 
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<!-- 注解配置 -->
	<context:annotation-config />

	<!--允许使用注解方式配置事务 -->
	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- 自动扫描的包名 -->
	<context:component-scan base-package="com.lxl" />

	<!-- 对标注@PersistenceContext的类经行增强，引入代理后的EntityManager实例 -->
	<bean
		class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

	<!-- 对标注@Repository的类经行增强，将EntityManager异常转换为SpringDAO体系的异常 -->
	<bean
		class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

	<!-- 属性文件 -->
	<context:property-placeholder location="/WEB-INF/properties/**/*.properties" />

	<!-- 数据源 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>


	<!-- JPA 实体管理工厂 -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceXmlLocation" value="classpath:META-INF/persistence.xml" />
		<property name="dataSource" ref="dataSource" />
		<property name="persistenceUnitName" value="ServicePlatform" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="true" />
				<property name="generateDdl" value="true" />
				<property name="databasePlatform" value="org.hibernate.dialect.MySQL5Dialect" />
			</bean>
		</property>
	</bean>

	<!-- JPA 事务管理 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="dataSource" ref="dataSource" />
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
	

</beans>

 dispatcher-servlet.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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 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/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/mvc 
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
	<!-- 默认的注解映射的支持 -->
	<mvc:annotation-driven />

	<!-- 自动扫描的包名 -->
	<context:component-scan base-package="com.lxl" />


	<!-- 配置一下对json数据的转换 <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
		<property name="messageConverters"> <list> <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean> 
		</list> </property> </bean> -->

	<!-- 视图解析器 -->
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/view" />
		<property name="suffix" value=".jsp" />
	</bean>

	<!-- 对静态资源文件的访问 方案一 （二选一） -->
	<mvc:default-servlet-handler />

	<!-- 对静态资源文件的访问 方案二 （二选一） <mvc:resources mapping="/images/**" location="/images/" 
		cache-period="31556926"/> <mvc:resources mapping="/js/**" location="/js/" 
		cache-period="31556926"/> <mvc:resources mapping="/css/**" location="/css/" 
		cache-period="31556926"/> -->
		

</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="ServicePlatform"
		transaction-type="RESOURCE_LOCAL">
	</persistence-unit>
</persistence>

 

 

实体bean

 

package com.lxl.bsp.identity.entity;

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

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

@Entity
@Table(name = "bd_id")
public class Identity implements Serializable {
	private static final long serialVersionUID = -8763611811485844772L;

	@Id
	@GeneratedValue(strategy = GenerationType.TABLE)
	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 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 Boolean getDr() {
		return dr;
	}

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

	@Override
	public String toString() {
		return "Identity [id=" + id + ", code=" + code + ", value=" + value
				+ ", prefix=" + prefix + ", suffix=" + suffix
				+ ", description=" + description + ", length=" + length
				+ ", creator=" + creator + ", createDate=" + createDate
				+ ", modifier=" + modifier + ", modifyDate=" + modifyDate
				+ ", dr=" + dr + "]";
	}

}

 

 

IdentityDaoImpl.java

 

package com.lxl.bsp.identity.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.lxl.bsp.api.exception.ServicePlatformException;
import com.lxl.bsp.identity.entity.Identity;

@Repository
public class IdentityDaoImpl implements IIdentityDao {

	@PersistenceContext
	private EntityManager em;

	@Transactional(propagation = Propagation.REQUIRED)
	public Identity create(Identity data) {
		em.persist(data);
		return data;
	}

	@Override
	public Identity retriver(String id) throws ServicePlatformException {
		Long pk = Long.valueOf(id);
		return em.find(Identity.class, pk);
	}

	@Override
	public Identity update(Identity data) throws ServicePlatformException {
		em.persist(data);
		return data;
	}

	@Override
	public void delete(String id) throws ServicePlatformException {
		em.remove(retriver(id));
	}
}

 IdentityController.java

 

 

package com.lxl.bsp.identity.controller;

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

import javax.annotation.Resource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.lxl.bsp.api.exception.ServicePlatformException;
import com.lxl.bsp.identity.dao.IIdentityDao;
import com.lxl.bsp.identity.entity.Identity;

@Controller
@RequestMapping("identity")
public class IdentityController {

	private static Log log = LogFactory.getLog(IdentityController.class);

	@Resource
	private IIdentityDao dao;

	@RequestMapping("retriver")
	@ResponseBody
	public Identity retriver(@RequestParam String id)
			throws ServicePlatformException {
		return dao.retriver(id);
	}

	@RequestMapping("create")
	@ResponseBody
	public Identity create() throws ServicePlatformException {
		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);
		log.debug(returnData);
		return returnData;
	}

	@RequestMapping("update")
	@ResponseBody
	public Identity update() throws ServicePlatformException {
		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);
		log.debug(returnData);
		return returnData;
	}

	@RequestMapping("delete")
	public void delete(@RequestParam String id) throws ServicePlatformException {
		dao.delete(id);
	}

}

 

 

数据表结构DDL

 

-- ----------------------------
-- Table structure for bd_id
-- ----------------------------
DROP TABLE IF EXISTS `bd_id`;
CREATE TABLE `bd_id` (
  `id` bigint(30) NOT NULL,
  `code` varchar(100) DEFAULT NULL,
  `create_date` datetime DEFAULT NULL,
  `creator` varchar(30) DEFAULT NULL,
  `description` varchar(255) DEFAULT NULL,
  `dr` tinyint(1) DEFAULT NULL,
  `length` int(11) DEFAULT NULL,
  `modifier` varchar(30) DEFAULT NULL,
  `modify_Date` datetime DEFAULT NULL,
  `prefix` varchar(10) DEFAULT NULL,
  `suffix` varchar(10) DEFAULT NULL,
  `value` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 

 

附件中是项目压缩包，只要电脑上安装了数据库，解压即可运行，数据库名称是osd

 

SpringHibernateJPA事务管理无法提交 
2013年12月18日 01:03

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

0 0

采纳的答案

说明：<context:component-scan base-package="com.lxl" /> 
这个扫描组件默认会扫描@Component,@Service,@Repository,@Controller注解，也就是说，你的业务层和持久层的bean被扫描了两次，因为你两个xml文件中都有这个配置。而Controller层的bean要比业务层和持久层的bean晚加载，所以会覆盖它们，而你在控制层中又没有事务配置（也就是dispatcher-servlet.xml文件中没有事务控制），所以可能导致事务不起作用。

如果是上面这个问题，那么：dispatcher-servlet.xml这么配置，只扫描@Controller注解：
<!-- controller扫描设置 -->
<context:component-scan base-package="com.lxl" use-default filters="false">
<context:include-filter type="annotation"      expression="org.springframework.stereotype.Controller" />
</context:component-scan>

applicationController这么配置，不扫描@Controller主键：
<context:component-scan base-package="com.lxl">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
</context:component-scan>

2013年12月18日 12:57
0 0

你的jpa没有配置扫描javabean 的路径啊？

<property name="scanPackages" value="com.inspur.domain" />

个人签名:健康宝宝

2013年12月18日 13:36
0 0

You config has some issues. You have 2 component-scanS in applicationContext.xml and dispatcher-servlet.xml. Check some material to see what the difference is in these 2 xmlS.

2013年12月18日 09:55

相关推荐

    非注解Springmvc+spring+hibernate 入门实例

    在非注解方式下，你需要配置Hibernate的`hibernate.cfg.xml`文件，设置数据库连接参数，并在实体类上使用JPA的`@Entity`注解。此外，还需要创建`SessionFactory`，它是Hibernate的主要工作单元，负责创建`Session`...

    spring3.0 mvc+hibernate3.6 +jpa 注解实例

    在本实例中，我们探讨的是一个基于Spring 3.0、Hibernate 3.6和Java Persistence API (JPA) 的集成应用，其中充分利用了注解来简化开发过程。这是一个适用于初学者和经验丰富的开发者深入了解这些技术如何协同工作的...

    Spring集成Jpa(Hibernate实现)

    4. **Spring配置**：在Spring应用中集成JPA，首先需要在配置文件（如`applicationContext.xml`或使用Java配置类）中配置数据源、JPA供应商（这里是Hibernate）、实体扫描路径等。例如，使用Java配置可能如下： ```...

    采用struts2,spring3,hibernate的全注解方式实现的demo

    总之，这个“全注解方式实现的demo”展示了如何整合Struts2、Spring3和Hibernate，利用注解简化配置，提高开发效率。对于初学者，这是一个很好的学习资源，可以深入理解这三大框架的协同工作以及注解在实际项目中的...

    spring3.1 struts2.3 hibernate4.1 jpa集成小例子

    5. **定义实体类**：创建Java类，用@Entity注解标记为数据库表的映射对象，使用JPA注解如@Id、@Column等进行字段映射。 6. **编写DAO和Service**：使用Spring的@Autowired注解注入SessionFactory或EntityManager，...

    Spring集成Hibernate所需jar包

    整合Spring和Hibernate，通常需要在Spring配置文件中定义DataSource、SessionFactory和TransactionManager，然后通过@Autowired注解将它们注入到需要使用的地方。同时，可以利用Spring的HibernateTemplate或...

    基于jpa+hibernate+spring+spring mvc注解方式项目

    **基于JPA+Hibernate+Spring+Spring MVC注解方式项目详解** 在现代Java Web开发中，Spring框架扮演了核心角色，而Spring MVC作为其MVC（Model-View-Controller）实现，提供了强大的Web应用程序构建能力。同时，JPA...

    spring-boot 集成hibernate

    在本文中，我们将深入探讨如何将Spring Boot与Hibernate集成，并使用Druid作为数据库连接池。首先，我们需要理解这三个核心组件： 1. **Spring Boot**: 是一个由Pivotal团队提供的开源框架，它简化了创建独立的、...

    Spring+Hibernate+Jpa+Struts2整合实例

    标题 "Spring+Hibernate+Jpa+Struts2整合实例" 描述的是一个综合性的Web开发教程，它将四个关键的Java技术框架集成在一起，用于构建高效的企业级应用程序。这个实例涵盖了Spring作为整体应用的管理框架，Hibernate...

    Spring + JPA + Hibernate配置

    标题“Spring + JPA + Hibernate配置”涉及到的是Java开发中常用的三个框架——Spring、Java Persistence API (JPA) 和Hibernate的集成与配置。这是一份关于如何将这些框架结合使用的教程或参考资料，可能包含了实现...

    spring mvc + spring + hibernate 全注解整合开发视频教程 11

    在本教程中，我们将深入探讨如何使用Spring MVC、Spring和Hibernate三大框架进行全注解的整合开发。这个视频教程系列的第11部分，重点可能是建立在前几部分的基础之上，进一步深化对这三个核心技术的理解和实践。 ...

    spring+springmvc+hibernate+jpa搭建

    9. **编写实体类**：根据数据库表结构，创建对应的Java实体类，并使用JPA注解来定义字段与数据库列的映射。 10. **创建DAO和Service层**：编写数据访问对象（DAO）和业务服务层（Service），利用Hibernate和JPA进行...

    Spring3.2_Hibernate4.2_JPA2全注解实例

    Spring 3.2、Hibernate 4.2 和 JPA 2.0 是Java开发中用于构建企业级应用程序的重要框架和规范。在这个实例中，我们将会深入探讨这些技术如何协同工作，以及如何通过全注解的方式来简化开发过程。 首先，Spring 3.2 ...

    Spring 4.0.6+Hibernate 4.3.5 + Jpa+DBCP2

    在Spring框架中集成Hibernate和JPA，可以利用Spring的事务管理、数据源配置和DAO支持。DBCP2（Jakarta Commons DBCP2）是Apache的一个数据库连接池组件，用于提高数据库连接的效率和可管理性。在Spring中配置DBCP2...

    integer with spring struts hibernate mybatis jpa

    标题 "integer with spring struts hibernate mybatis jpa" 提示了这个压缩包包含的是一个集成多种技术的Java Web开发框架。这些技术包括Spring、Struts、Hibernate、MyBatis和JPA，它们都是Java领域中非常重要的...

    hibernate-4.3.5 与Spring（Spring MVC4.0.4）注解方式集成

    以上就是Hibernate 4.3.5与Spring（Spring MVC 4.0.4）注解方式集成的主要知识点。这个压缩包中的样例源码应包含这些组件的配置文件、实体类、DAO、Service、Controller以及相关的测试类，供开发者参考学习。通过...

    spring+springMVC+jpa+hibernate框架整合

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

    springmvc4+hibernate4 jpa实现整合（含jar包）

    通过参考和引用传智播客的免费教程，将springmvc4.1.6与hibernate4.3.10提供的JPA实现整合，使用mysql5.6.25,在MyEclipse2014中测试通过。可以作为web开发的基础框架使用。 使用说明： 1.需要安装mysql,并创建名为...

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

相关推荐

已解决问题

未解决问题

排行榜

Global site tag (gtag.js) - Google Analytics