神马文学网一对多关联映射(双向)
来源：百度文库 编辑：神马文学网 时间：2024/04/28 04:03:29
一对多双向，从实体类上讲究是在“多”的一端持有“一”的实例，并在配置文件中用标签将其配置上。这里有一点要特别注意，当两边都能够维护关系的时候，推荐让“多”的一端来做，做法上就是在“一”一端映射文件的标签中设置属性inverse="true"。另外，中为“多”一端表设置的外键要和中设置的外键要一样。1.实体模型：
2.关系模型：
3.实体类： Student.javapublic class Student {
private Integer id;
private String name;
private Classes classes;
//一系列的 setter.getter方法
@Override
public String toString() {
return "name of student: " + name;
}
} Classes.javapublic class Classes {
private Integer id;
private String name;
private Set students;
//一系列的setter.getter方法
@Override
public String toString() {
return "name of class: " + name;
}
} 4.映射文件： Student.hbm.xml <class name="com.sxt.hibernate.one2many.entity.Student" table="sxt_hibernate_student">
<id name="id" length="4">
<generator class="native">generator>
id>
<property name="name" length="10">property>
<many-to-one name="classes" column="class_id" cascade="save-update">many-to-one>
class> Classes.hbm.xml <class name="com.sxt.hibernate.one2many.entity.Classes" table="sxt_hibernate_class">
<id name="id" length="4">
<generator class="native">generator>
id>
<property name="name" length="10">property>
<set name="students" cascade="save-update" inverse="true">
<key column="class_id">key>
<one-to-many class="com.sxt.hibernate.one2many.entity.Student"/>
set>
class> 5.hibernate配置文件： 参见上一篇。 6.测试方法： public static void main(String[] args) {
Session session = HibernateUtils.getSession();
Transaction t = session.beginTransaction();
try {
/**
* 测试插入数据
*/
/* Classes classes = new Classes();//情况1:从"多"的一端保存(这完全就是个多对一的情况)
classes.setName("不一班");
Student student1 = new Student();
student1.setName("志朋");
student1.setClasses(classes);
//存储成功.sql语句如下:
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//为了不至于出现TransientObjectException,应先保存classes对象或者在中
//加上cascade="save-update,all"
session.save(student1);
Student student2 = new Student();
student2.setName("有朋");
student2.setClasses(classes);
//由于此时classes已经是持久化对象了,所以此处不会再存储一遍classes了
session.save(student2);
*/
/* Student student1=new Student();//情况2:从"一"的一端保存
student1.setName("志鹏");
Student student2=new Student();
student2.setName("有朋");
Set students=new HashSet();
students.add(student1);
students.add(student2);
Classes classes=new Classes();
classes.setName("不一班");
classes.setStudents(students);
//也能正确保存.sql语句如下：
//如果标签中没有inverse="true":(情况2.1)
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: update sxt_hibernate_student set class_id=? where id=?
//Hibernate: update sxt_hibernate_student set class_id=? where id=?
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student,
//由于默认inverse=false,student不负责维护关系,所以此时它的class_id为空;然后回来存储classes,而此时
//classes不得不来维护关系(发出update语句修改student的外键).
//如果标签中有inverse="true":(情况2.2)
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//但是插入的student记录class_id字段为空,因为"一"一端不再负责维护关系了.
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;
// 而在存储student时,虽然inverse="true"指明了由它来维护关联关系,所以他要先存主表class,
// 再回来存副表student,但是student发现它的classes为null,就把class_id字段设为了空.
session.save(classes);
*/
/* Classes classes=new Classes();//情况3
classes.setName("不一班");
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);
//同样能正确保存.sql语句如下:
//如果标签中有inverse="true",cascade="save-update":
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//这种情况student的class_id也有了,因为在插入student时,由student来维护了关系,而它引用的class已经是持久化的了.
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;
// 而在存储student时,inverse="true"指明了由它来维护关联关系,所以他要先存主表class,再回来存副表student
session.save(classes);*/
/**
* 小结:情况1是我们提倡的;
* 情况2.1虽然也能实现正确插入,但是效率低;
* 情况2.2显然是错误的;
* 情况3虽然也能实现,并且效率也不低,但是编程上比较麻烦.
*/
/**
* 测试加载数据
*/
Student student=(Student)session.get(Student.class, 3);
System.out.println(student);
System.out.println(student.getClasses());
t.commit();
} catch (HibernateException e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
}
2.关系模型： 3.实体类： Student.javapublic class Student { private Integer id;
private String name;
private Classes classes;
//一系列的 setter.getter方法
@Override
public String toString() {
return "name of student: " + name;
}
} Classes.javapublic class Classes {
private Integer id;
private String name;
private Set
//一系列的setter.getter方法
@Override
public String toString() {
return "name of class: " + name;
}
} 4.映射文件： Student.hbm.xml <class name="com.sxt.hibernate.one2many.entity.Student" table="sxt_hibernate_student">
<id name="id" length="4">
<generator class="native">generator>
id>
<property name="name" length="10">property>
<many-to-one name="classes" column="class_id" cascade="save-update">many-to-one>
class> Classes.hbm.xml <class name="com.sxt.hibernate.one2many.entity.Classes" table="sxt_hibernate_class">
<id name="id" length="4">
<generator class="native">generator>
id>
<property name="name" length="10">property>
<set name="students" cascade="save-update" inverse="true">
<key column="class_id">key>
<one-to-many class="com.sxt.hibernate.one2many.entity.Student"/>
set>
class> 5.hibernate配置文件： 参见上一篇。 6.测试方法： public static void main(String[] args) {
Session session = HibernateUtils.getSession();
Transaction t = session.beginTransaction();
try {
/**
* 测试插入数据
*/
/* Classes classes = new Classes();//情况1:从"多"的一端保存(这完全就是个多对一的情况)
classes.setName("不一班");
Student student1 = new Student();
student1.setName("志朋");
student1.setClasses(classes);
//存储成功.sql语句如下:
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//为了不至于出现TransientObjectException,应先保存classes对象或者在
//加上cascade="save-update,all"
session.save(student1);
Student student2 = new Student();
student2.setName("有朋");
student2.setClasses(classes);
//由于此时classes已经是持久化对象了,所以此处不会再存储一遍classes了
session.save(student2);
*/
/* Student student1=new Student();//情况2:从"一"的一端保存
student1.setName("志鹏");
Student student2=new Student();
student2.setName("有朋");
Set
students.add(student1);
students.add(student2);
Classes classes=new Classes();
classes.setName("不一班");
classes.setStudents(students);
//也能正确保存.sql语句如下：
//如果
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: update sxt_hibernate_student set class_id=? where id=?
//Hibernate: update sxt_hibernate_student set class_id=? where id=?
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student,
//由于默认inverse=false,student不负责维护关系,所以此时它的class_id为空;然后回来存储classes,而此时
//classes不得不来维护关系(发出update语句修改student的外键).
//如果
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//但是插入的student记录class_id字段为空,因为"一"一端不再负责维护关系了.
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;
// 而在存储student时,虽然inverse="true"指明了由它来维护关联关系,所以他要先存主表class,
// 再回来存副表student,但是student发现它的classes为null,就把class_id字段设为了空.
session.save(classes);
*/
/* Classes classes=new Classes();//情况3
classes.setName("不一班");
Student student1=new Student();
student1.setName("志鹏");
student1.setClasses(classes);
Student student2=new Student();
student2.setName("有朋");
student2.setClasses(classes);
Set
students.add(student1);
students.add(student2);
classes.setStudents(students);
//同样能正确保存.sql语句如下:
//如果
//Hibernate: insert into sxt_hibernate_class (name, id) values (?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//Hibernate: insert into sxt_hibernate_student (name, class_id, id) values (?, ?, ?)
//这种情况student的class_id也有了,因为在插入student时,由student来维护了关系,而它引用的class已经是持久化的了.
//存储过程是这样的:存classes时,由于有cascade="save-update",它会先触发存储student;
// 而在存储student时,inverse="true"指明了由它来维护关联关系,所以他要先存主表class,再回来存副表student
session.save(classes);*/
/**
* 小结:情况1是我们提倡的;
* 情况2.1虽然也能实现正确插入,但是效率低;
* 情况2.2显然是错误的;
* 情况3虽然也能实现,并且效率也不低,但是编程上比较麻烦.
*/
/**
* 测试加载数据
*/
Student student=(Student)session.get(Student.class, 3);
System.out.println(student);
System.out.println(student.getClasses());
t.commit();
} catch (HibernateException e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
}
一对多关联映射(双向)
多对多关联映射(双向)
Eclipse快速上手Hibernate--7. 关联映射(一对多) (2
Eclipse快速上手Hibernate--7. 关联映射(一对多) (3)
hibernate多对一关联映射
Eclipse快速上手Hibernate--8. 关联映射(多对多)
“一对多”专户理财!是什么？
Hibernate对多表关联查询
双向看人看己
双向看人看已
双向成交量
专户理财“一对多”开闸在即
好友日志-------一对人物 多个版本
好友日志-------一对人物 多个版本
“一对多”专户理财! “一对多”是什么？股海史上最灵活的“黑珍珠”号浮出水面！
关联交易
关联企业
各种关联
过程模式之O/R映射映射
过程模式之O/R映射映射
多名“京官”赴基层履新 双向交流任职或成常态
英汉双向字典DIY
农民工急需双向转型
双向可控硅原理图