hibernate 一对多

一对多双向关联映射:

* 在一一端的集合上使用<key>,在对方表中加入一个外键指向一一端

* 在多一端采用<many-to-one>

 

注意:<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致,否则引用字段的错误

inverse="true" 表示将控制权交给另一方

cascade="save-update" 级联操作,例如学生和班级只用save一个就行。

Classes.java

private int id;

private String name;

private Set students;

Student.java

private int id;

private String name;

private Classes classes;

<hibernate-mapping package="com.demo.hibernate">

<class name="Classes" table="t_classes">

<id name="id">

<generator class="native"/>

</id>

<property name="name"/>

<set name="students" inverse="true" cascade="all">

<key column="classesid"/>

<one-to-many class="Student"/>

</set>

</class>

</hibernate-mapping>

<hibernate-mapping>

<class name="com.demo.hibernate.Student" table="t_student">

<id name="id">

<generator class="native"/>

</id>

<property name="name"/>

<many-to-one name="classes" column="classesid"/>

</class>

</hibernate-mapping>

public class One2ManyTest extends TestCase {

public void testSave1() {

Session session = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Student student1 = new Student();

student1.setName("10");

session.save(student1);

Student student2 = new Student();

student2.setName("祖儿");

session.save(student2);

Set students = new HashSet();

students.add(student1);

students.add(student2);

Classes classes = new Classes();

classes.setName("2012A");

classes.setStudents(students);

//可以正确保存

session.save(classes);

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

}

public void testSave2() {

Session session = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Classes classes = new Classes();

classes.setName("2012A");

session.save(classes);

Student student1 = new Student();

student1.setName("飞飞");

student1.setClasses(classes);

session.save(student1);

Student student2 = new Student();

student2.setName("菲菲");

student2.setClasses(classes);

session.save(student2);

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

}

public void testSave3() {

Session session = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Classes classes = new Classes();

classes.setName("2012A");

Student student1 = new Student();

student1.setName("飞飞");

student1.setClasses(classes);

Student student2 = new Student();

student2.setName("菲菲");

student2.setClasses(classes);

Set students = new HashSet();

students.add(student1);

students.add(student2);

classes.setStudents(students);

//可以正确保存

session.save(classes);

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

}

public void testLoad1() {

Session session = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Classes classes = (Classes)session.load(Classes.class, 1);

System.out.println("classes.name=" + classes.getName());

Set students = classes.getStudents();

for (Iterator iter=students.iterator(); iter.hasNext();) {

Student student = (Student)iter.next();

System.out.println("student.name=" + student.getName());

}

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

}

public void testLoad2() {

Session session = null;

try {

session = HibernateUtils.getSession();

session.beginTransaction();

Student student = (Student)session.load(Student.class, 1);

System.out.println("student.name=" + student.getName());

System.out.println("student.classes.name=" + student.getClasses().getName());

session.getTransaction().commit();

}catch(Exception e) {

e.printStackTrace();

session.getTransaction().rollback();

}finally {

HibernateUtils.closeSession(session);

}

}

}

hihernate一对多关联映射(双向Classes<----->Student)

如果在”一“一端维护一对多关联关系,hibernate会发出多余的udpate语句,所以我们一般在多

的一端来维护关联关系

关于inverse属性:

inverse主要用在一对多和多对多双向关联上,inverse可以被设置到集合标签<set>上,

默认inverse为false,所以我们可以从”一“一端和”多“一端维护关联关系,

如果设置成inverse为true,则我们只能从多一端来维护关联关系

注意:inverse属性,只影响数据的存储,也就是持久化

在设置了inverse为true 以后,数据时可以insert 进入对应的表,但是,hibernate不会再发出update 更新操作,因此插入数据库中的数据无效,对应的关系没有办法维护,数据是null

关系交给谁维护,那么,存数据时,最后存入数据库

Cascade:all

inverse和cascade

* inverse是关联关系的控制方向

* cascade操作上的连锁反应

时间: 2024-10-09 15:18:06

hibernate 一对多的相关文章

菜鸟学习Hibernate——一对多关系映射

Hibernate中的关系映射,最常见的关系映射之一就是一对多关系映射例如学生与班级的关系,一个班级对应多个学生.如图: Hibernate中如何来映射这两个的关系呢? 下面就为大家讲解一下: 1.创建实体类Classes和实体类Student Classes.java package com.bjpowernode.hibernate; import java.util.Set; public class Classes { private int id; private String nam

hibernate 一对多关联关系(详细分析)

在领域模型中, 类与类之间最普遍的关系就是关联关系. 在 UML 中, 关联是有方向的. 以 Customer 和 Order 为例: 一个用户能发出多个订单, 而一个订单只能属于一个客户. 从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联 单向关联 双向关联 单向 n-1 单向 n-1 关联只需从 n 的一端可以访问 1 的一端 域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Cus

Hibernate一对多操作

--------------------siwuxie095 Hibernate 一对多操作 以客户和联系人为例,客户是一,联系人是多 即 一个客户里面有多个联系人,一个联系人只能属于一个客户 注意:这里的客户是公司级的,即 公司,联系人 即 公司里的员工 (一)一对多映射配置 第一步:创建两个实体类,客户和联系人 第二步:让两个实体类之间互相表示 (1)在客户实体类中表示多个联系人 (2)在联系人实体类中表示所属客户 第三步:配置映射关系 「一般一个实体类对应一个映射配置文件」 (1)配置基本

Hibernate一对多、多对一关联

一对多.多对一关联:在多方加外键 示例:Group(一方)和User(多方),一个Group可以有多个User,每个User只能属于一个Group   多对一单向关联 在User(多方)中建Group(一方)对象,并添加@ManyToOne注解 1.建Group实体类和User实体类,添加Annotation注解,如下 @Entity @Table(name="_group") //group在MySQL中是关键字,不能直接做表名 public class Group { privat

Hibernate一对多单向关联和双向关联映射方法及其优缺点 (待续)

一对多关联映射和多对一关联映射实现的基本原理都是一样的,既是在多的一端加入一个外键指向一的一端外键,而主要的区别就是维护端不同.它们的区别在于维护的关系不同: 一对多关联映射是指在加载一的一端数据的同时加载多的一端的数据 多对一关联映射是指在加载多的一端数据的同时加载一的一端的数据 而单向一对多关联映射是在一的一端维护关系的,具有以下的缺点: 必须先保存多的一端后才可以保存一的一端,所以在保存多的一端时多的一端不知道一的一端是否 存在相应的数据,所以只能将维护的关系字段设置为null,如果为非空

hibernate 一对多|多对一

一对多:(一个客户对应多个联系人) 客户实体:Customer.java package cn.future.domain; import java.util.HashSet; import java.util.Set; public class Customer { /* * CREATE TABLE `cst_customer` ( `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)', `cust_name` VAR

Hibernate 一对多双向关联Demo

以Classes[班级]和Student[学生]为例的Demo //Classes.java public class Classes implements Serializable { private long cid; private String cname; private String cdesc; private Set<Student> students; //get和set } //Student .java public class Student implements Se

Hibernate 一对多单向关联Demo

以Classes[班级]和Student[学生]为例的Demo Classes .java public class Classes implements Serializable { private long Cid; private String Cname; private String Cdesc; private Set<Student> students; //get和set } Student .java public class Student implements Seria

Hibernate—— 一对多 和 多对多关联关系映射(xml和注解)总结(转载)

One to Many 映射关系 多对一单向外键关联(XML/Annotation) 一对多单向外键关联(XML/Annotation) 懒加载和积极加载 一对多双向外键关联(XML/Annotation) Many to Many 映射关系 多对多单向外键关联(XML/Annotation) 多对多双向外键关联(XML/Annotation) set的inverse元素详解 问题小结 关联关系的优缺点 多对一单向外键关联关系 注意多对一关联是多方持有一方的引用.看一个例子,去淘宝购物,那么一个

hibernate一对多双向关联

14.一对多双向关联 1.在多的一方关联一的一方,多的一方直接维护了关系,所以多的一方没有inverse属性,多的一方在保存自己的时候直接保存了外键,效率高. 2.建立关系和保存对象,可以对应两个映射文件,保存多的一方自己对应自己的映射文件,建立关系可以使用一的一方表的inverse属性.这样发出update语句,效率低了.一对多,从多的一方建立关系,效率高. 例子 在student这边保存属性private Classess classess; 在student.hbm.xml文件在<clas