如表:
第一步:实现Student表和Teacher表的实体类
第二步:
1、进行Student表 的配置,如下:
<class name="entity.Student">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_student</param>
</generator>
</id>
<property name="name"></property>
<many-to-one name="teacher" column="teacherid" class="entity.Teacher"></many-to-one>
</class>
PS:
在学生的配置上的这句代码:<many-to-one name="teacher" column="teacherid" class="entity.Teacher"></many-to-one>
<many-to-one>元素建立了 teacher 属性和Teacher表的teacherid之间的映射。
name:设定持久化类的属性。
column:设定持久化类的属性对应的表的外键。
class:设定持久化的属性的类型。
2、进行Teacher表的配置,如下:
<class name="entity.Teacher">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_teacher</param>
</generator>
</id>
<property name="name"></property>
</class>
第三步:使用hibernate.cfg.xml映射其的路径
<mapping resource="entity/Student.hbm.xml" />
<mapping resource="entity/Teacher.hbm.xml" />
第四步:进行数据操作
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
Teacher teacher = new Teacher("李炎恢");
Student student1 = new Student("吴者然");
Student student2 = new Student("何开");
try {
student1.setTeacher(teacher);
student2.setTeacher(teacher);
tx = session.beginTransaction();
session.save(teacher);
session.save(student1);
session.save(student2);
tx.commit();
System.out.println("保存成功!!!");
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
}finally{
HibernateSessionFactory.closeSession();
}
效果图:
配置单向一对多关联
如表:
第一步:实现Teacher2表和Student2表的实体类
第二步:
1、进行Teacher2表 的配置,如下:
<class name="entity.Teacher2">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_teacher2</param>
</generator>
</id>
<property name="name"></property>
<set name="student2">
<key column="teacher2id"></key>
<one-to-many class="entity.Student2" />
</set>
</class>
2、进行Student2表 的配置,如下:
<class name="entity.Student2">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_student2</param>
</generator>
</id>
<property name="name"></property>
</class>
第三步:使用hibernate.cfg.xml映射其的路径
<mapping resource="entity/Student2.hbm.xml" />
<mapping resource="entity/Teacher2.hbm.xml" />
第四步:进行数据操作
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
Teacher2 teacher = new Teacher2("李炎恢");
Student2 student1 = new Student2("吴者然");
Student2 student2 = new Student2("何开");
try {
teacher.getStudent2().add(student1);
teacher.getStudent2().add(student2);
tx = session.beginTransaction();
session.save(teacher);
session.save(student1);
session.save(student2);
tx.commit();
System.out.println("保存成功!!!");
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
}finally{
HibernateSessionFactory.closeSession();
}
效果图:
配置单向多对多关联
如表:
这时产生了一个新表
第一步:实现Pupil表和Subject表的实体类
第二步:
1、进行Pupil表 的配置,如下:
<class name="entity.Pupil">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_pupil</param>
</generator>
</id>
<property name="name"></property>
<set name="subject" table="p_s">
<key column="p_id" />
<many-to-many class="entity.Subject" column="s_id" />
</set>
</class>
2、进行Subject表的配置,如下:
<class name="entity.Subject">
<id name="id">
<generator class="sequence">
<param name="sequence">seq_subject</param>
</generator>
</id>
<property name="name"></property>
<set name="pupil" table="p_s">
<key column="s_id" />
<many-to-many class="entity.Pupil" column="p_id" />
</set>
</class>
第三步:使用hibernate.cfg.xml映射其的路径
<mapping resource="entity/Pupil.hbm.xml" />
<mapping resource="entity/Subject.hbm.xml" />
第四步:进行数据操作
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
Pupil pupil1 = new Pupil("吴者然");
Pupil pupil2 = new Pupil("景临境");
Subject subject1 = new Subject("Java");
Subject subject2 = new Subject("php");
subject1.getPupil().add(pupil1);
subject1.getPupil().add(pupil2);
subject2.getPupil().add(pupil1);
try {
tx = session.beginTransaction();
session.save(pupil1);
session.save(pupil2);
session.save(subject1);
session.save(subject2);
tx.commit();
System.out.println("保存成功!!!");
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
}finally{
HibernateSessionFactory.closeSession();
}
效果图:
相关推荐
本实例将深入探讨Hibernate中的三种基本关联关系:一对一(One-to-One)、一对多(One-to-Many)以及多对多(Many-to-Many)的实现方式。 1. **一对一关联**: 一对一关联通常出现在两个实体之间存在唯一对应关系...
本篇文章将深入探讨Hibernate中注解的一对多、多对多和一对一关系映射。 ### 一对多关系 在现实生活中,例如一个班级有一个班主任,而班主任可以管理多个学生,这就是典型的“一对多”关系。在Hibernate中,我们...
本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先,一对多关系在数据库中很常见,...
本文将深入探讨Hibernate框架下“多对一”和“一对多”的关联关系,并通过一个具体示例来阐述其操作流程与实现细节。 ### Hibernate中的“多对一”和“一对多” 在数据库设计中,“多对一”(Many-to-One)和“一...
hibernate 一对多和多对一的理解 自己的个人看法 大家也来看看
本文将深入探讨Hibernate中的一对多、多对一、一对一以及多对多四种关系映射的配置实例,帮助开发者更好地理解和运用这些关系。 ### 一对多关系(One-to-Many) 在数据库设计中,一对多关系是最常见的一种关联,...
本案例主要探讨的是Hibernate中的一对多关系映射,这是一种常见的对象关系映射(ORM)配置,用于表示一个实体与多个其他实体之间的关联。 在传统的数据库设计中,一对多关系是指一个表(父表)中的记录可以与另一个...
在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...
本篇文章将详细讲解"hibernate一对多与多对一"的关系映射概念,以及如何在实际开发中进行配置和使用。 首先,我们来看一下“一对多”关系。在现实世界中,这种关系可以对应到例如一个班级有多个学生,或者一个人...
在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系数据库模型映射方式,用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射,并通过实际例子解析相关...
本文将深入探讨Hibernate中的一对多和多对一映射关系,并通过一个实际的demo演示它们在增删查改操作中的应用。 首先,我们要理解什么是数据库的关联关系。在数据库设计中,我们经常遇到一种情况,即一个实体可能与...
【标题】:“Hibernate多对一关联demo” 在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库操作。本教程将详细解释如何在Hibernate中实现多对一的关联关系,以及如何通过一个实际的示例...
在Java的持久化框架Hibernate中,多对多(Many-to-Many)关系是数据库中常见的关联类型,它允许一个实体实例对应多个其他实体实例,反之亦然。在本案例中,我们将深入探讨如何使用Hibernate来处理多对多的关系映射,...
在这个“hibernate实例(一对多,多对一)”的主题中,我们将深入探讨两种重要的关联关系:一对一(One-to-One)和一对多(One-to-Many)。 **一对一关联(One-to-One)** 在一对一关联中,一个实体与另一个实体之间...
本文将详细解析"hibernate一对多映射"的概念、配置及其实现过程,以帮助理解并掌握这一核心特性。 首先,我们要明白在关系型数据库中,"一对多"关系意味着一个实体(比如一个部门)可以有多个相关实体(如部门下的...
标题中的“hibernate一对多实例”指的是在Java编程中使用Hibernate框架处理数据库关系时的一对多关联映射。Hibernate是Java领域中的一个流行对象关系映射(ORM)框架,它允许开发者用面向对象的方式操作数据库,从而...
**标题:“Hibernate双向一对多经典实例”** 在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库操作,使得开发者能够用面向对象的方式处理数据。本实例将聚焦于Hibernate中的一对多关系...
在本主题中,我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**: 在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多...
在Java的持久化框架Hibernate中,"多对一"关联关系是一种常见的对象关系映射(ORM)设计,它表示一个实体(子项)可以与多个其他实体(父项)相关联,而每个父项可能被多个子项引用。在数据库层面,这通常对应于一个...