hibernate one-to-many级联删除问题

最新推荐文章于 2019-10-11 16:42:43 发布
最新推荐文章于 2019-10-11 16:42:43 发布
阅读量225 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate Java junit Eclipse JDBC
现有两个对象：Diary和DiaryReply
表结构如下： 

-- ----------------------------
-- Table structure for osblog_diary_reply
-- ----------------------------
CREATE TABLE `osblog_diary_reply` (
  `id` int(11) NOT NULL auto_increment,
  `diary_id` int(11) NOT NULL,
  `author` varchar(20) NOT NULL,
  `author_url` varchar(100) default NULL,
  `author_email` varchar(50) default NULL,
  `owner_only` int(11) default NULL,
  `content` text NOT NULL,
  `create_time` datetime NOT NULL,
  `last_modify_time` datetime default NULL,
  `last_update_time` timestamp NULL default NULL on update  CURRENT_TIMESTAMP,
  PRIMARY KEY  (`id`),
  KEY `r_diary_reply_fk` (`diary_id`),
  CONSTRAINT `fk_r_diary_reply` FOREIGN KEY (`diary_id`) REFERENCES `osblog_diary` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for osblog_diary
-- ----------------------------
CREATE TABLE `osblog_diary` (
  `id` int(11) NOT NULL auto_increment,
  `blog_id` varchar(32) NOT NULL,
  `catalog_id` int(11) NOT NULL COMMENT '日记分类',
  `author` varchar(20) default NULL,
  `title` varchar(200) NOT NULL,
  `content` text NOT NULL,
  `diary_size` int(11) NOT NULL,
  `view_count` int(11) NOT NULL,
  `reply_count` int(11) NOT NULL,
  `refer` varchar(100) default NULL COMMENT '引用地址',
  `weather` varchar(20) default NULL,
  `mood_level` smallint(6) default NULL COMMENT '心情指数',
  `tags` varchar(100) default NULL,
  `last_read_time` datetime default NULL,
  `last_reply_time` datetime default NULL,
  `reply_notify` smallint(6) default NULL COMMENT '回复是否通知',
  `locked` smallint(6) default NULL COMMENT '是否锁定（保留）',
  `create_time` datetime NOT NULL,
  `last_modify_time` datetime default NULL,
  `last_update_time` timestamp NULL default NULL on update CURRENT_TIMESTAMP,
  PRIMARY KEY  (`id`),
  KEY `r_catalog_diary_fk` (`catalog_id`),
  KEY `r_blog_diary_fk` (`blog_id`),
  CONSTRAINT `fk_r_blog_diary` FOREIGN KEY (`blog_id`) REFERENCES `osblog_site_blog` (`blog_id`),
  CONSTRAINT `fk_r_catelog_diary` FOREIGN KEY (`catalog_id`) REFERENCES `osblog_diary_catalog` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;





/*******diary.hbm.xml*******/
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="cn.edu.zjut.software.swordye.model">
	<class
		name="Diary"
		table="osblog_diary"
	>
		<meta attribute="sync-DAO">false</meta>
		<id
			name="id"
			type="integer"
			column="id"
		>
			<generator class="native"/>
		</id>

		<property
			name="author"
			column="author"
			type="string"
			not-null="false"
			length="20"
		/>
		<property
			name="title"
			column="title"
			type="string"
			not-null="true"
			length="200"
		/>
		<property
			name="content"
			column="content"
			type="string"
			not-null="true"
		/>
		<property
			name="diarySize"
			column="diary_size"
			type="integer"
			not-null="true"
			length="10"
		/>
		<property
			name="viewCount"
			column="view_count"
			type="integer"
			not-null="true"
			length="10"
		/>
		<property
			name="replyCount"
			column="reply_count"
			type="integer"
			not-null="true"
			length="10"
		/>
		<property
			name="refer"
			column="refer"
			type="string"
			not-null="false"
			length="100"
		/>
		<property
			name="weather"
			column="weather"
			type="string"
			not-null="false"
			length="20"
		/>
		<property
			name="moodLevel"
			column="mood_level"
			type="java.lang.Short"
			not-null="false"
			length="5"
		/>
		<property
			name="tags"
			column="tags"
			type="string"
			not-null="false"
			length="100"
		/>
		<property
			name="lastReadTime"
			column="last_read_time"
			type="timestamp"
			not-null="false"
		/>
		<property
			name="lastReplyTime"
			column="last_reply_time"
			type="timestamp"
			not-null="false"
		/>
		<property
			name="replyNotify"
			column="reply_notify"
			type="java.lang.Short"
			not-null="false"
			length="5"
		/>
		<property
			name="locked"
			column="locked"
			type="java.lang.Short"
			not-null="false"
			length="5"
		/>
		<property
			name="createTime"
			column="create_time"
			type="timestamp"
			not-null="true"
		/>
		<property
			name="lastModifyTime"
			column="last_modify_time"
			type="timestamp"
			not-null="false"
		/>

		<many-to-one
			name="blog"
			column="blog_id"
			class="SiteBlog"
			not-null="true"
		>
		</many-to-one>
		<many-to-one
			name="diaryCatalog"
			column="catalog_id"
			class="DiaryCatalog"
			not-null="true"
		>
		</many-to-one>


		<set name="diaryReplies" inverse="true"   cascade="delete" lazy="true">
			<key column="id"/>   //这里配置是错误的，应该改为子表里的diary_id属性列
			<one-to-many class="DiaryReply"/>
		</set>


	</class>	
</hibernate-mapping>


*****diaryReply.hbm.xml******

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="cn.edu.zjut.software.swordye.model">
	<class
		name="DiaryReply"
		table="osblog_diary_reply"
	>
		<meta attribute="sync-DAO">false</meta>
		<id
			name="id"
			type="integer"
			column="id"
		>
			<generator class="native"/>
		</id>

		<property
			name="blogId"
			column="blog_id"
			type="string"
			not-null="true"
			length="32"
		/>
		<property
			name="authorName"
			column="author"
			type="string"
			not-null="true"
			length="20"
		/>
		<property
			name="authorUrl"
			column="author_url"
			type="string"
			not-null="false"
			length="100"
		/>
		<property
			name="authorEmail"
			column="author_email"
			type="string"
			not-null="false"
			length="50"
		/>
		<property
			name="ownerOnly"
			column="owner_only"
			type="integer"
			not-null="false"
			length="10"
		/>
		<property
			name="content"
			column="content"
			type="string"
			not-null="true"
		/>
		<property
			name="createTime"
			column="create_time"
			type="timestamp"
			not-null="true"
		/>
		<property
			name="lastModifyTime"
			column="last_modify_time"
			type="timestamp"
			not-null="false"
		/>
		<many-to-one
			name="diary"
			column="diary_id"
			class="Diary"
			not-null="true"
			cascade="none"
		>
		</many-to-one>


	</class>	
</hibernate-mapping>



现要删除Diary的时候级联删除，跟该Diary关联的DiaryReply 

public void deleteDiary(Diary diary) {
      getSession().delete(diary);		
}


报如下错误：
org.springframework.dao.DataIntegrityViolationException: Could not execute JDBC batch update; nested exception is org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
Caused by: org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:71)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:202)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:235)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:144)
at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:297)
at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:27)
at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:985)
at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:333)
at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:106)
at org.springframework.orm.hibernate3.HibernateTransactionManager.doCommit(HibernateTransactionManager.java:575)
at org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:662)
at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:632)
at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:314)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:117)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:166)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:204)
at $Proxy13.deleteDiary(Unknown Source)
at cn.edu.zjut.software.swordye.service.DiaryServiceTest.testDeleteDiary(DiaryServiceTest.java:114)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
at org.unitils.UnitilsJUnit4TestClassRunner$CustomTestMethodRunner.executeMethodBody(UnitilsJUnit4TestClassRunner.java:231)
at org.junit.internal.runners.TestMethodRunner.runUnprotected(TestMethodRunner.java:81)
at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
at org.junit.internal.runners.TestMethodRunner.runMethod(TestMethodRunner.java:75)
at org.junit.internal.runners.TestMethodRunner.run(TestMethodRunner.java:45)
at org.junit.internal.runners.TestClassMethodsRunner.invokeTestMethod(TestClassMethodsRunner.java:66)
at org.unitils.UnitilsJUnit4TestClassRunner$CustomTestClassMethodsRunner.invokeTestMethod(UnitilsJUnit4TestClassRunner.java:155)
at org.junit.internal.runners.TestClassMethodsRunner.run(TestClassMethodsRunner.java:35)
at org.junit.internal.runners.TestClassRunner$1.runUnprotected(TestClassRunner.java:42)
at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
at org.junit.internal.runners.TestClassRunner.run(TestClassRunner.java:52)
at org.unitils.UnitilsJUnit4TestClassRunner.run(UnitilsJUnit4TestClassRunner.java:95)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:38)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
Caused by: java.sql.BatchUpdateException: Cannot delete or update a parent row: a foreign key constraint fails (`osblogdb_test/osblog_diary_reply`, CONSTRAINT `fk_r_diary_reply` FOREIGN KEY (`diary_id`) REFERENCES `osblog_diary` (`id`))
at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:1213)
at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:912)
at org.apache.commons.dbcp.DelegatingStatement.executeBatch(DelegatingStatement.java:297)
at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:58)
at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:195)
... 39 more


一开始总以为是one-to-many里cascade配置错误，但是尝试了各种配置后还是一样报这个错误。经过多翻网上查找终于在一篇文章里看了。原来是one-to-many端的<key column="id" />配置错误，因为*.hbm.xml文件是由我用HibernateSynchronizer生成的，一直就没有注意这个key值。该值应该是many端外键所在的属性列名，即：DiaryReply所对应表的diary_id。
看来这个HibernateSynchronizer工具有bug啊！害偶花了N多时间找这个错误。。以后用这个工具的时候要小心鸟。
iteye_346
关注
专栏目录
Hibernate：one-to-many（一对多）关联映射详解
SirouW的博客
09-04 3092
对one-to-many关联映射进行论述
Hibernate one-to-many / many-to-one关系映射
07-03
NULL 博文链接：https://xiangtui.iteye.com/blog/680938
hibernate 一对多(one-to-many)双向关联
xx510long的博客
03-22 187
一对多（one-to-many）双向关联实例（Department- Employee） 这里的一对多双向关联是在域模型(实体对象模型)上的概念,在关系数据库中,只存在外键参照关系,而且总是由"many"方参照"one"方,因为这样才能消除冗余数据,因上关系数据库实际上只支持多对一或一对一的单向关联.在实体(类与类之间)各种各样的关系中,数多对一的的单向关联关系与数据库中的外键参照关系最匹配了....
hibernate映射技巧one-to-many(单项一对多)
yangxn的专栏
09-09 4978
    一对多关系在系统实现中也很常见。典型的例子就是父亲与孩子的关系。 而在我们现在的这个示例中，每个用户（TUser）都关联到多个地址(TAddress)，如一个用户可能拥有办公室地址、家庭地址等多个地址属性。这样，在系统中，就反应为一个“一对多”关联。一对多关系分为单向一对多关系和双向一对多关系。单向一对多关系只需在“一”方进行配置，双向一对多关系需要在关联双方均加以配置。 
hibernate的many-to-one的级联删除问题
zjlolife的专栏
05-05 2903
在数据库中，级联删除，一般是删除主表记录的时候，级联删除子表的记录。 但是在Hibernate中，如果在many-to-one设置了级联all，或者delete，比如student中的many-to-one设置了all， 那么在删除持久化的student的时候，也会级联删除teacher对应的记录。这与数据库的操作不大相同，要注意了！！！
hibernate one to many(many to one)
sn_cmf16的博客
10-28 295
多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来 一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来 而单向一对多关联映射是在一的一端维护关系的 1.实体类： one to many:定义多段Set集合，需要实例化HasSet many to one:定义一端对象 2.映射文件： ...
hibernate-one-to-many
05-18
<many-to-one name="department" class="com.example.Department" column="DEPARTMENT_ID" /> ``` 如果使用注解，上述关系已经在实体类中定义。 ### 3. 操作一对多关系 在实际应用中，我们可以通过Hibernate提供...
Hibernate one-to-many-annotation
07-30
在Hibernate中，`one-to-many`关系是常见的实体间关系之一，表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...
hibernate one-to-many 单/双向关联映射配置心得
03-16
本文主要关注Hibernate中的一个核心概念——一对一（One-to-One）、一对多（One-to-Many）和多对一（Many-to-One）关联映射，特别是关于“一到多”单向和双向关联映射的配置心得。 首先，让我们了解“一到多”关联...
hibernate one to many(many to one)
qq_42247220的博客
09-10 443
   多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来   一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来   而单向一对多关联映射是在一的一端维护关系的 1.实体类：                   one to many:定义多段Set集合，需要实例化HasSet                    many to o...
Hibernate one to many(many to one) 配置
03-20
NULL 博文链接：https://fqh1987.iteye.com/blog/791845
Hibernate one to many
weixin_43632687的博客
10-11 242
Hibernate one to many mapping solutions This problem can be solved in two different ways. One is to have a foreign key column in account table i.e. EMPLOYEE_ID. This column will refer to primary key o...
Hibernate one-to-many many-to-one 的配置
u011598529的专栏
01-11 4729
写东西，总是能发现问题，技术上的漏洞正是在这个时候得到弥补的。 表与表之间的关系有多种。一对多很典型，现配置一下，(teacher表 ，student表 )如下 Model: one : private Set ter = new HashSet(); many: private Student stu; Model.hbm.xml one 的一方
hibernate的one-to-many
zheng_zhimeng的专栏
04-05 523
1.one-to-many 的单向 one-to-many的单向是指在一端维护关系，一端用set存储多端对象，由于one-to-many 在添加或维护关系时比较麻烦，开发中不建议使用one-to-many的单向。 one-to-many 的单向如何表示，举例说明一下 一对多关系：Message （留言）和Comment(评论） 实例如下： Message对象：public Class Me
Hibernate之one-to-many
07-20 664
Hibernate之one-to-many 感悟：基于架构的设计，主要在于xml配置文件的编写 原理：表中一对多的实现是在表中使用外键关联，也就是通过一张表的主键做为另一个表的外键来建立一对多关系。 在hibernate的pojo类中实现一对多关系的方法是在主控类中个设置一个集合属性来包含对方类的若干对象，而在另一个类中，只包含主控类的一个对象，从而实现一对多关系的建立。
hibernate one to many 双向（不推荐单向）
Belle_Chou的博客
05-06 320
many to one name指定了类定义的变量相同，”class”指定了关系属性的类型（也指定了与哪一个表关联）， “column”属性是指定这个关联属性是按照”class_id”列的值，然后去查classes表。 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!DOCTYPE hibernate-mapping PUBLIC "-//H...
hibernate one to many 单向
Belle_Chou的博客
05-04 146
package hibernate.belle; import java.util.Set; public class Classes { private String id; private String name; private Set studentss; /** * @return the name */ publi...
hibernate之one-to-many详细
ttitfly的笔记
10-01 162
1. 拿Classes和Student为例。 [code="java"] package com.test; import java.util.Set; public class Classes { private Integer classesId; private String classesName; private Set students; ...
hibernate 一对多（one to many）级联删除
crazycat03的专栏
05-15 598
我这里说的是一对多单向级联删除，其他需要级联的相应修改cascade即可   以Order和Item为例 1 bean 类 public class Order implements java.io.Serializable {   private Set items = new HashSet(0);   相应的get,set方法 }   public class Item...
深入解析Hibernate：多对一关系与级联操作
"本文档详细介绍了Hibernate框架中的many-to-one（多对一）关系映射以及cascade（级联）操作的使用，通过一个User和Group的例子进行解释，并提供了相关的hbm.xml配置文件片段。" 在Java开发中，尤其是在使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值