Hibernate自身一对多和多对多关系映射

一对多关系映射大家都明白，关系双方都一个含有对方多个引用，但自身一对多很多同学都不明白什么意思，那么首先我就说明一下什么是自身一对多，其实也很好理解，自身一对多就是自身含有本身的多个引用，例如新闻类别，新闻包含体育新闻和政治新闻，体育新闻内有含有足球新闻和篮球新闻，其实他们都属于新闻，只是名字不同而已，下面我们就以新闻类别为例来具体说明一下：

首先我们来看一下新闻类别的类图：

类图：category

从上面的图我们可以看出：每一个新闻类别都有一个父类别和一个孩子类别的set集合，这个父类别和孩子类别里面都是自身的引用，这样就行了自身一对多的对象关系

下面看一下具体的新闻实体类：Category.Java

[java] view plain copy

print?

  1. public class Category
  2. {
  3. private Long id;
  4. private String name;
  5. private Category parentCategory;
  6. private Set<Category> childCategories;
  7. public Category(String name, Category parentCategory,
  8. Set<Category> childCategories)
  9. {
  10. this.name = name;
  11. this.parentCategory = parentCategory;
  12. this.childCategories = childCategories;
  13. }
  14. public Category()
  15. {
  16. }
  17. *******set、get方法省略
  18. }

看完具体的实体类之后我们下面看一下其具体的配置，其实他的配置中没什么特别的地方，仅仅只是他的配置中包含了一对多和多对一的共同标签存在而已：他即含有多的一方的<set>标签。也含有一的一方的<many-to-one>标签：

Category.hbm.xml配置文件

[html] view plain copy

print?

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5. <class name="com.shengsiyuan.hibernate.Category" table="categories">
  6. <id name="id" column="id" type="long">
  7. <generator class="increment"></generator>
  8. </id>
  9. <property name="name" type="string" >
  10. <column name="name" length="50" ></column>
  11. </property>
  12. <set name="childCategories" cascade="all" inverse="true">
  13. <key column="category_id"></key>
  14. <one-to-many class="com.shengsiyuan.hibernate.Category"/>
  15. </set>
  16. <many-to-one name="parentCategory" column="category_id" class="com.shengsiyuan.hibernate.Category">
  17. </many-to-one>
  18. </class>
  19. </hibernate-mapping>

下面我们来看一下在自身一对多的关系下进行增删改查的示例：

[java] view plain copy

print?

  1. import java.util.HashSet;
  2. import org.hibernate.Session;
  3. import org.hibernate.SessionFactory;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  6. public class HibernateTest2
  7. {
  8. private static SessionFactory sessionFactory;
  9. static
  10. {
  11. try
  12. {
  13. sessionFactory = new Configuration().configure()
  14. .buildSessionFactory();
  15. }
  16. catch (Exception ex)
  17. {
  18. ex.printStackTrace();
  19. }
  20. }
  21. public static void main(String[] args)
  22. {
  23. Session session = sessionFactory.openSession();
  24. Transaction tx = null;
  25. try
  26. {
  27. tx = session.beginTransaction();
  28. Category category1 = new Category("level1", null, new HashSet<Category>());
  29. Category category2 = new Category("level2", null, new HashSet<Category>());
  30. Category category3 = new Category("level2", null, new HashSet<Category>());
  31. Category category4 = new Category("level3", null, new HashSet<Category>());
  32. Category category5 = new Category("level3", null, new HashSet<Category>());
  33. Category category6 = new Category("level3", null, new HashSet<Category>());
  34. Category category7 = new Category("level3", null, new HashSet<Category>());
  35. category2.setParentCategory(category1);
  36. category3.setParentCategory(category1);
  37. category1.getChildCategories().add(category2);
  38. category1.getChildCategories().add(category3);
  39. category4.setParentCategory(category2);
  40. category5.setParentCategory(category2);
  41. category2.getChildCategories().add(category4);
  42. category2.getChildCategories().add(category5);
  43. category6.setParentCategory(category3);
  44. category7.setParentCategory(category3);
  45. category3.getChildCategories().add(category6);
  46. category3.getChildCategories().add(category7);
  47. Category category = (Category)session.get(Category.class, new Long(1));
  48. System.out.println(category.getChildCategories().iterator().next().getName());
  49. session.delete(category);
  50. tx.commit();
  51. }
  52. catch(Exception ex)
  53. {
  54. if(null != tx)
  55. {
  56. tx.rollback();
  57. }
  58. }
  59. finally
  60. {
  61. session.close();
  62. }
  63. }
  64. }

在很多实际开发过程中，多对多的映射关系也是比较常见的，最为明显的例子就是我们常用的学生选课示例，一个学生可以选多门课，一门课也可以由多个学生去选，这样就形成了多对多的映射关系，现在我们就以学生选课的实例来看一看多对多关系映射。由于在多对多映射中，双向多对多用的的比较多，并且单向多对多也比较简单，所以我们就以双向多对多进行讲解

我们先把必要的实体类和实体映射文件写好：

先简单看一下实体类：

student.java

[java] view plain copy

print?

  1. /** 学生实体类 */
  2. public class Student {
  3. private Long id;                //对象标识符(OID)
  4. private String name;            //姓名
  5. private String grade;           //所在班级
  6. private Set<Course> courses;    //所有所选课程的集合
  7. public Student(){}              //无参数的构造方法
  8. ******set、get方法省略
  9. }

Course.java

[java] view plain copy

print?

  1. /** 课程实体类 */
  2. public class Course {
  3. private Long id;                //对象标识符(OID)
  4. private String name;            //课程名
  5. private Double creditHours;     //课时数
  6. private Set<Student> students;  //选择了这门课程的学生的集合
  7. public Course(){}             //无参数的构造方法
  8. ******set、get方法省略
  9. }

下一步编写实体映射文件：

Student.hbm.xml

[html] view plain copy

print?

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6. <!-- 映射持久化类 -->
  7. <class name="com.zxf.domain.Student" table="student">
  8. <!-- 映射对象标识符 -->
  9. <id name="id" column="id" type="long">
  10. <generator class="native" />
  11. </id>
  12. <!-- 映射普通属性 -->
  13. <property name="name" />
  14. <property name="grade" />
  15. <!-- 映射集合属性,指定连接表 -->
  16. <set name="courses" table="student_course">
  17. <!-- 用key元素指定本持久类在连接表中的外键字段名 -->
  18. <key column="student_id" />
  19. <!-- 映射多对多关联类 -->
  20. <many-to-many column="course_id"
  21. class="com.zxf.domain.Course" />
  22. </set>
  23. </class>
  24. </hibernate-mapping>
  25. Course.hbm.xml：
  26. <?xml version="1.0" encoding="UTF-8"?>
  27. <!DOCTYPE hibernate-mapping PUBLIC
  28. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  29. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  30. <hibernate-mapping>
  31. <!-- 映射持久化类 -->
  32. <class name="com.zxf.domain.Course" table="course">
  33. <!-- 映射对象标识符 -->
  34. <id name="id" column="id" type="long">
  35. <generator class="native" />
  36. </id>
  37. <!-- 映射普通属性 -->
  38. <property name="name" />
  39. <property name="creditHours" column="credit_hours" />
  40. <!-- 映射集合属性,指定连接表 -->
  41. <set name="students" table="student_course" inverse="true">
  42. <!-- 用key元素指定本持久类在连接表中的外键字段名 -->
  43. <key column="course_id" />
  44. <!-- 映射多对多关联类 -->
  45. <many-to-many column="student_id" class="com.zxf.domain.Student" />
  46. </set>
  47. </class>
  48. </hibernate-mapping>

下面具体看一下增删改查的具体测试的关键代码：

增加数据测试：

[java] view plain copy

print?

  1. <span xmlns="http://www.w3.org/1999/xhtml" style=""><span xmlns="http://www.w3.org/1999/xhtml" style="">tran = session.beginTransaction();
  2. Student stu1 = new Student("xiaoli", "two");
  3. Student stu2 = new Student("xiaoming", "two");
  4. Student stu3 = new Student("xiaoqiang", "two");
  5. Course course1 = new Course("java", 3.0);
  6. Course course2 = new Course("c#", 5.0);
  7. //stuset.add(stu1);
  8. //stuset.add(stu2);
  9. //course1.setStudents(stuset);
  10. //session.save(course1);
  11. couset.add(course1);
  12. couset.add(course2);
  13. stu1.setCourses(couset);
  14. session.save(stu1);
  15. tran.commit();</span></span>

测试结论：如果想保存数据成功，不管是主控方还是被控方，如果想通过一次保存即可把双方数据保存，需要把实体配置中的cascade属性设置为all或者save-update，由于设置为all包含delete，在删除数据中，删除一条信息会导致相对应表的多条或者全部信息被删掉，所以一般配置save-update。

时间： 2024-10-17 15:18:29

Hibernate自身一对多和多对多关系映射的相关文章

Hibernate中一对多和多对一关系

1.单向多对一和双向多对一的区别? 只需要从一方获取另一方的数据时 就使用单向关联双方都需要获取对方数据时 就使用双向关系 部门--人员 使用人员时如果只需要获取对应部门信息(user.getdeptarment())不需要 从部门下的人员信息时,就配置成单向 多对一 使用部门时如果只需要获取部门下人员信息(deptartmanet.getusers())不需要 从人员获取部门信息时,就配置成单向 一对多 既要获取部门下人员 deptartmanet.getusers()又要从人员获取部门信息

mybatis 一对一，一对多，多对多关系映射查询操作

定义两个类(对应数据库内两张表) User ,Account,每个Account属于一个User User类 及其 对应的IUserDao package com.itheima.domain; import java.io.Serializable; import java.util.Date; import java.util.List; public class User implements Serializable { private Integer id; private Strin

Hibernate映射（二）——多对一关系映射

上篇学习了Hibernate的基本映射,也就是单表映射,很容易就能理解,但是对于关系数据库来说,表之间存在关系是比不可少的,关系数据库中存在的关系是通过主外键建立起来的,反应到Hibernate要如何通过对象表现呢?下面我们就继续学习Hibernate的对象关系映射. 我们先从最常见的多对一和一对多关系开始: 多对一 所谓多对一,在数据库中即在多的一端添加外键关联到一的一端,比如用户(User)和用户所在组(Group)的关系:一个User只属于一个Group,一个Group有多个Group,并

深入浅出Hibernate（二）多对一关系映射

学习Hibernate是为了更方便的操作数据库,在数据库中的关系模型中存在多对一的关系,比如下图所示的员工和部门之间的关系,那么这种关系在Hibernate中如何映射呢?让我用一个小Demo来详细讲解. 建立映射分为以下几步: 1.设计domain对象Department.Employee,代码如下: package cn.itcast.hibernate.domain; public class Department { private int id; private String name;

Hibernate学习笔记(五) — 多对多关系映射

多对多关系映射 多对多建立关系相当于在第三张表中插入一行数据 多对多解除关系相当于在第三张表中删除一行数据 多对多修改关系相当于在第三张表中先删除后增加 多对多谁维护效率都一样.看需求 在实际开发过程中,多对多的映射关系比较常见. 学生选课示例,一个学生可以选多门课,一门课也可以由多个学生去选,这样就形成了多对多的映射关系 public class Student implements Serializable { private static final long serialVersionU

Hibernate多对多关系映射(建表)

下边讲述Hibernate多对多关系映射. 多对多关系的表的结构为: 两个实体表,还包含一个关系表,关系表为复合主键,如果要使用Hibernate多对多关系映射,则关系表必须只包含两个字段,如果生成了Hibernate多对多关系映射,则中间关系表不会生成实体(即没有对应的pojo类,更没有其映射文件). 1.建立表 DROP TABLE user_course ; DROP TABLE user ; DROP TABLE course ; CREATE TABLE user ( userid  

JPA一对多和多对一关系

1-m:多的一方为关系维护端,关系维护端负责外键纪录的更新,关系被维护端没有权力更新外键纪录. 维护端注解 Java代码   @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH, CascadeType.MERGE, CascadeType.REMOVE }, fetch = FetchType.EAGER, mappedBy = "order") 被维护端注解 Java代码   @ManyToOne(casc

使用annotation配置hibernate（3）：多对多关系配置

数据库表结构 Student.java 1 @Entity 2 @Table(name = "student") 3 public class Student { 4 @Id 5 @Column(name = "id") 6 @GenericGenerator(name = "generator",strategy = "native") 7 @GeneratedValue(generator = "generato

Django 一对多，多对多关系解析

[转]Django 一对多,多对多关系解析 Django 的 ORM 有多种关系:一对一,多对一,多对多. 各自定义的方式为 : 一对一: OneToOneField 多对一: ForeignKey 多对多: ManyToManyField 上边的描述太过数据而缺乏人性化,我们来更人性化一些: 多个属于一个,即 belong to :  ForeignKey,多个属于一个 一个有一个,即 has one: OneToOneField 一个有很多个,即 has many:  lots of A b