- 浏览: 577951 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (411)
- webservice (3)
- oracle (37)
- sqlserver (8)
- j2ee (56)
- linux (7)
- javaweb (47)
- office (1)
- struts (23)
- hibernate (11)
- spring (29)
- 网络 (2)
- tomcat (13)
- tongweb (0)
- weblogic (0)
- powerdesiginer (3)
- svn (3)
- js (20)
- ie (2)
- 编译 (3)
- css (2)
- 操作系统 (5)
- Android (41)
- jbpm4.3 (1)
- fckeditor (3)
- 操作excel (2)
- db2常用命令 (1)
- ibatis (5)
- mysql (16)
- 表达式语言 (1)
- java方式调用存储过程 (1)
- ca (1)
- linux客户端 (1)
- 电子数码 (1)
- 行业应用 (12)
- 开发工具 (4)
- 面试 (1)
- 计算机原理 (1)
- NOSQL (5)
- 虚拟机 (1)
- nginx (0)
- velocity (2)
- jndi (1)
- spring mvc (39)
- springmvc (32)
- 安全 (5)
- htmleditor (6)
- iphone4 (1)
- html (4)
- jstl (2)
- ckeditor (5)
- 连接池 (1)
- jquery (6)
- 分页 (1)
- 技术研发规则 (1)
- javamail (1)
- maven (2)
- upload (1)
- log (1)
- 测试 (10)
- spring roo (1)
- 版本控制 (2)
- find bugs (0)
- jsf (0)
- springroo (0)
- 小道理 (1)
- 小道理,技术标准 (1)
- jsf (0)
- bitbao (2)
- redmine (3)
- 团队意识 (1)
- mybatis (2)
- jquery mobile (1)
- flexpaper (0)
- json (4)
- URLRewriteFilte (1)
- html5 (1)
- 都乐保活动 (0)
- openfire (0)
- TreeMap (1)
- build (0)
- javaweb,tag (0)
- algorithm (1)
- tag (2)
- 扯淡 (0)
- mac (2)
- 叶一火(老一) (1)
- 游玩 (1)
- 编码 (1)
- 上线部署 (0)
- 研发管理 (0)
- thumbnailator (2)
- 旅游 (0)
- bingweibo (1)
- 杂谈 (4)
- ktv (1)
- weibo (1)
- 爱情 (2)
- 饮食 (1)
- MediaWiki (1)
- git (1)
- 版本库 (1)
- servlet (1)
- 感悟 (1)
- 人生 (1)
- highcharts (1)
- poi (0)
- websphere (0)
- php (1)
最新评论
-
woshixushigang:
good
org.springframework.beans.TypeMismatchException: Failed to convert property valu -
nathanleewei:
org.springframework.jdbc.core.B ...
org.springframework.beans.TypeMismatchException: Failed to convert property valu -
浪禾木:
请问是ckeditor\contents.css吗?改过以后 ...
ckeditor自动换行问题 -
simusuishi:
刚哥威武!
ckeditor取值赋值问题 -
a455642158:
收割完毕……
Android开源项目源码下载(不断更新中)
hibernate 一对多 单向
classes---->student (one--->many)
类:
one
public class Classes {
private Integer id;
private String name;
private Set students;
}
many
public class Student {//不用动
private Integer id;
private String name;
}
hbm.xml
Classes.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
< hibernate-mapping package="com.model">
<class name="Classes" table="classes" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" type="java.lang.String" />
<set name="students">
<key column="class_id" />
<one-to-many class="com.model.Student" />
</set>
</class>
< /hibernate-mapping>
Student.hbm.xml(不用动)
<?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
< hibernate-mapping package="com.zd.model">
<class name="Student" table="student" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" length="50" type="java.lang.String" />
</class>
< /hibernate-mapping>
测试用例:
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.model.Classes;
import com.model.Student;
public class OneToManyTest extends TestCase {
public void testSave1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Student stu1 = new Student();
stu1.setName("z3");
Student stu2 = new Student();
stu2.setName("l4");
session.save(stu1); //一定要先保存,要不是瞬时对象
session.save(stu2);
Set stuSet = new HashSet();
stuSet.add(stu1);
stuSet.add(stu2);
Classes c = new Classes();
c.setName("Java Class");
c.setStudents(stuSet);
session.save(c);
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: insert into student (name) values (?)
Hibernate: insert into student (name) values (?)
Hibernate: insert into classes (name) values (?)
Hibernate: update student set class_id=? where id=?
Hibernate: update student set class_id=? where id=?
注:表student 的字段class_id必须null(若为not null,就会报错)。多了2条update, 所以one-to-many保存时,不太好,不推荐。
public void testGet1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Classes c = (Classes) session.get(Classes.class, new Integer(2));
System.out.println("Class.name=" + c.getName());
Set stuSet = c.getStudents();
if(stuSet != null && !stuSet.isEmpty()){
for(Iterator it = stuSet.iterator(); it.hasNext();){
Student s = (Student) it.next();
System.out.println("student.name=" + s.getName());
}
}
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Class.name=Java Class
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from student students0_ where students0_.class_id=?
student.name=l4
student.name=z3
}
小结:one-to-may 是只配在one这端,但many另一端的表中要用外键与这相对应
<set name="students"> //name : one 中的set变量
<key column="class_id" /> //column 表student的外键字段class_id
<one-to-many class="com.model.Student" /> //class指many的类
</set>
===============================================================
双向(many-to-one) ,在多的一端配个多对一:
修改如下:
类:
public class Student {
private Integer id;
private String name;
private Classes classes;
}
hbm.xml
Student.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
< hibernate-mapping package="com.zd.model">
<class name="Student" table="student" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" length="50" type="java.lang.String" />
<many-to-one name="classes" column="class_id"></many-to-one>
</class>
< /hibernate-mapping>
测试用例:
public void testSave2(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Classes c = new Classes();
c.setName("php");
Student stu1 = new Student();
stu1.setName("a1");
stu1.setClasses(c);
Student stu2 = new Student();
stu2.setName("a2");
stu2.setClasses(c);
session.save(c); //先保存班级
session.save(stu1);
session.save(stu2);
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
================================================
关于inverse属性:
inverse主要用在一对多和多对多双向关联上,inverse可以被设置到集合标签<set>上,
默认inverse为false,所以我们可以从”一“一端和”多“一端维护关联关系,
如果设置成inverse为true,则我们只能从多一端来维护关联关系
注意:inverse属性,只影响数据的存储,也就是持久化
<set name="students" inverse="true"> //inverse为true,则我们只能从多一端来维护关联关系
<key column="class_id" />
<one-to-many class="com.zd.model.Student" />
</set>
inverse和cascade
* inverse是关联关系的控制方向
* cascade操作上的连锁反应
1、到底在哪用cascade="..."?
cascade属性并 不是多对多关系一定要用的,有了它只是让我们在插入或删除对像时更方便一些,只要在cascade的源头上插入或是删除,所有 cascade的关系就会被自己动的插入或是删除。便是为了能正确的cascade,unsaved-value是个很重要的属性。Hibernate通 过这个属性来判断一个对象应该save还是update,如果这个对象的id是unsaved-value的话,那说明这个对象不是 persistence object要save(insert);如果id是非unsaved-value的话,那说明这个对象是persistence object(数据库中已存在),只要update就行了。saveOrUpdate方法用的也是这个机制。 2、到底在哪用inverse="ture"? “set的inverse属性决定是否把对set的改动反映到数据库中去。inverse=false————反映;inverse=true————不反映”inverse属性默认为false inverse 属性默认是false的,就是说关系的两端都来维护关系。这个意思就是说,如有一个Student, Teacher和TeacherStudent表,Student和Teacher是多对多对多关系,这个关系由TeacherStudent这个表来表 现。那么什么时候插入或删除TeacherStudent表中的记录来维护关系呢?在用hibernate时,我们不会显示的对 TeacherStudent表做操作。对TeacherStudent的操作是hibernate帮我们做的。hibernate就是看hbm文件中指 定的是"谁"维护关系,那个在插入或删除"谁"时,就会处发对关系表的操作。前提是"谁"这个对象已经知道这个关系了,就是说关系另一头的对象已经set 或是add到"谁"这个对象里来了。前面说过inverse默认是false,就是关系的两端都维护关系,对其中任一个操作都会处发对表系表的操作。当在 关系的一头,如Student中的bag或set中用了inverse="true"时,那就代表关系是由另一关维护的(Teacher)。就是说当这插 入Student时,不会操作TeacherStudent表,即使Student已经知道了关系。只有当Teacher插入或删除时才会处发对关系表的 操作。所以,当关系的两头都用inverse="true"是不对的,就会导致任何操作都不处发对关系表的操作。当两端都是inverse= "false"或是default值是,在代码对关系显示的维护也是不对的,会导致在关系表中插入两次关系。 在一对多关系中 inverse就更有意义了。在多对多中,在哪端inverse="true"效果差不多(在效率上)。但是在一对多中,如果要一方维护关 系,就会使在插入或是删除"一"方时去update"多"方的每一个与这个"一"的对象有关系的对象。而如果让"多"方面维护关系时就不会有update 操作,因为关系就是在多方的对象中的,直指插入或是删除多方对象就行了。当然这时也要遍历"多"方的每一个对象显示的操作修关系的变化体现到DB中。不管 怎样说,还是让"多"方维护关系更直观一些。 (1)对one-to-many而言,改变set,会让hibernate执行一系列的update语句, 不会delete/insert数据 (2)对many-to-many而言,改变set,只修改关系表的数据,不会影响many-to-many的另一方。 (3)虽然one-to-many和many-to-many的数据库操作不一样,但目的都是一个:维护数据的一致性。 3、cascade和inverse有什么区别? 可以这样理解,cascade定义的是关系两端对象到对象的级联关系;而inverse定义的是关系和对象的级联关系。 inverse只对set+one-to-many(或many-to-many)有效,对many-to-one, one-to-one无效。cascade对关系标记都有效。 inverse对集合对象整体起作用,cascade对集合对象中的一个一个元素起作用,如果集合为空,那么cascade不会引发关联操作。 比如将集合对象置为null, school.setStudentSet(null) inverse导致hibernate执行:udpate STUDENT set SCHOOL_ID=null where SCHOOL_ID=? cascade则不会执行对STUDENT表的关联更新, 因为集合中没有元素。 再比新增一个school, session.save(school) inverse导致hibernate执行: for( 对(school的每一个student ){ udpate STUDENT set SCHOOL_ID=? where STUDENT_ID=? //将学生的school_id改为新的school的id } cascade导致hibernate执行: for( 对school的每一个student ){ session.save(aStudent); //对学生执行save操作 } extends:如果改变集合中的部分元素(比如新增一个元素), inverse: hibernate先判断哪些元素改变了,对改变的元素执行相应的sql cascade: 它总是对集合中的每个元素执行关联操作。 (在关联操作中,hibernate会判断操作的对象是否改变) 两个起作用的时机不同: cascade:在对主控方操作时,级联发生。 inverse: 在flush时(commit会自动执行flush),对session中的所有set,hibernate判断每个set是否有变化, 对有变化的set执行相应的sql,执行之前,会有个判断:if( inverse == true ) return;可以看出cascade在先,inverse在后。 inverse 对set + one-to-many 和 set + many-to-many 起的作用不同。hibernate生成的sql不同。 对one-to-many,hibernate对many方的数据库表执行update语句。 对many-to-many, hibernate对关系表执行insert/update/delte语句,注意不是对many方的数据库表而是关系表。 cascase 对set都是一致的,不管one-to-many还是many-to-many。都简单地把操作传递到set中的每个元素。所以它总是更新many方的数据库表。 |
inverse是<set>的属性,所以只能在one-to-many方设置.拿常用的例子来说custom为one,而order为many,当两者相互关联,如果inverse设为false,当order有变化的时候,首先按照order的变化对order表进行变更,而后custom发现order有变化,也会按照order的变化对order表进行变更。当inverse设为true时,若order发生变化,则只是按照order进行更新,而custome方不会再对order表进行变更.就是这么个区别
发表评论
-
spring mvc 乐观锁遇到的问题
2013-05-29 17:29 2002乐观锁问题:updateTime @version ... -
hibernate命名查询问题
2013-01-30 16:38 1322hibernate 注解 @OneToOne(fetc ... -
hibernate [Null value was assigned to a property of primitive type setter of sco
2012-12-25 19:51 1115今天开发时候 hibernate 查询报错,分析原因如下: ... -
hibernate4注解配置,纠结的一对多双向关联
2012-12-20 11:16 1766目前负责中行风险管理系统的数据核对加工模块,业务以及逻辑都已经 ... -
hibernate4 注解配置失误导致生成的表关联关系不对
2012-12-18 19:52 1232最近做ibm 风险管理系统,配置hibernate 注解时候看 ... -
eclipse codestyle和formate
2011-12-26 11:20 1060北京都乐宝软件信息技术公司的代码风格 -
Common-logging 与 Log4j的结合使用
2011-12-25 15:58 1207转自:http://hi.baidu.com/suofang/ ... -
ssh整合(转)
2011-09-06 14:50 1274终于,终于将SSH整合成 ... -
hibernate一对多关系采用外键映射时使用inverse的几种情况
2011-06-20 09:05 884对hibernate关系的维护比较头疼,遂总结下做个备份。 ... -
mappedBy
2011-06-15 14:42 1717对于mappedBy的理解: a) 只有OneToOne, ...
相关推荐
一、一对一(one-to-one)与一对多(one-to-many)关系 1. 一对一关系: 在现实世界中,如一个人只有一个身份证,这就是典型的"一对一"关系。在Hibernate中,可以通过@OneToOne注解实现。这种关系通常需要使用外键...
在Hibernate框架中,双向一对多关联映射是常见的对象关系映射(ORM)方式,用于在Java对象模型中表示数据库中的两个实体之间的多对一关系。在这个场景中,"一"端通常指的是一个实体可以拥有多个另一个实体的实例,而...
本文将深入探讨Hibernate中一对多(One-to-Many)关系的处理方式,特别是通过外键映射和inverse属性的应用场景。 #### 一对多关系概念 一对多关系在数据库设计中非常常见,它指的是一个实体可以与多个其他实体关联...
在数据库世界中,一对多(One-to-Many)关系是一种常见的关联类型,其中一个表(父表)可以与多个其他表(子表)相关联。在NHibernate中,配置这种映射关系对于理解和使用ORM至关重要。 一对多关系意味着一个实体...
本实例将详细讲解如何在Hibernate中实现Many-to-One关系映射,这是一种常见的数据库关联,表示一个实体可以与多个其他实体相关联。 在Many-to-One关系中,通常一个实体(如部门)可以有多个相关实体(如员工),而...
以上就是关于Hibernate中一对一单向外键关联的基本介绍。通过理解和熟练掌握这种关联方式,开发者可以更高效地设计和管理数据库模型,提升应用性能。在实际项目中,还需结合业务场景灵活运用,并注意性能优化。通过...
在Java的持久化框架Hibernate中,一对多(Many-to-One)和多对一(One-to-Many)的关系映射是数据库关系模型中的常见关联类型。本文将深入探讨这两种关联方式在使用Hibernate时的配置,包括基于注解(Annotation)和...
多对多双向关联 <br>注意映射规则: <set name="roles" table="t_user_role"><br> <key column="userid"/><br> <many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/><br> </set><br><br>table...
在上述配置中,`<one-to-many>`标签定义了`User`到`Order`的一对多关系,而`<many-to-one>`标签定义了`Order`到`User`的多对一关系。`inverse="true"`意味着`Order`端负责维护关系,即当删除一个`Order`时,其对应的...
在Java的持久化框架Hibernate中,One-to-Many映射是一种常见的关系映射方式,它表示一个实体(比如一个用户)可以与多个其他实体(比如用户的订单)进行关联。在这个场景下,"用户"是一方,称为"One","订单"是另...
`<many-to-one>`标签用于表示从`Orgnization`类到另一个`Orgnization`类的单向一对多关系,这里通过`parent`属性表示子组织对父组织的引用。`column`属性指定了数据库中用于存储外键的列名。 #### 2. 双向一对多...
本主题聚焦于Hibernate框架中的“一对多”映射关系,这是一种常见的关联类型,它允许一个实体类与多个其他实体类建立联系。 在Hibernate中,"一对多"映射表示一个父实体可以有多个子实体。这种关系在现实世界中有很...
- `many-to-one`关联可以用来表达多种类型的关系,包括一对一、一对多和多对一。 - 双向`many-to-one`关联的例子,比如麻将桌上的玩家位置与玩家之间的关系。 #### 三、`one-to-one`关联管理 `one-to-one`关联...
本篇文章将全面探讨Hibernate的关联映射学习,包括一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)以及多对多(Many-to-Many)四种关系映射。 首先,一对一关联映射(One-to-One)是两个实体...
关联映射主要包括四种类型:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)。下面我们将逐一探讨这些关联映射的配置方法。 1. **一对一关联映射** - **主键关联**...
1. **在父类的映射文件中**,使用`<one-to-many>`元素声明一对多关联,并通过`class`属性指定子类的全限定类名。 ```xml <hibernate-mapping> <!-- 其他映射 --> <set name="orders" inverse="true" cascade=...
本主题主要关注的是Hibernate中的一个关键概念——一对一(One-To-One)关联映射。一对一关联是两个实体之间的一种关系,其中每个实体最多只能与另一个实体的单个实例相关联。 ### 一对一关联的基本概念 一对一关联...
本教程聚焦于Hibernate中的单向一对多关联映射,这是一个常见的实体关系模型,广泛应用于各种业务场景。 在数据库设计中,一对多关系意味着一个父表记录可以与多个子表记录相关联。例如,一个学生可以有多个课程,...
- **多对多**:例如,一个`Student`和多个`Course`课程的关系,`inverse`属性通常放在独立的关系表中,并且只能在一方设置为`true`,另一方为`false`,以确保关系的正确维护。 #### 三、Cascade 属性详解 `cascade...