AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Hibernate框架【四】——基本映射——多对一和一对多映射

2023-07-28 183
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Hibernate框架【四】——基本映射——多对一和一对多映射

系列文章目录

Hibernate框架【三】——基本映射——一对一映射

基本映射——多对一和一对多映射

前言

由于公司项目上进行面向对象的架构设计对于ORM部分使用的是Spring Data JPA框架。将ORM完全交给Spring Data JPA框架，而Hibernate是Spring Data JPA的实现方式之一，通过对HIbernate框架的学习能够更好的理解ORM框架，以及Spring Data JPA框架。

下面的博客是对于Hibernate框架中的基本映射中的多对一和一对多映射进行的实践，总结的并不全面，旨在多对一和一对多映射关系有一个宏观了解并能够进行基本运用。


一、多对一映射是什么？

在 Hibernate 中，多对一关联映射表示多个实体关联到另一个实体，即多个从实体关联到一个主实体。这种关系常用于表示层级关系或父子关系。

在多对一关联映射中，存在两个实体，即主实体和从实体。从实体包含对主实体的引用，而主实体通常是拥有外键的一方。


1.案例：现在有两个实体User实体和Group，其中多个User属于一个Group，表现出多对一的关系。

①.实体结构

package com.wangwei.hibernate;
import java.util.Date;
public class User {
private Integer id;
    private String name;
    private Group group;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Group getGroup() {
        return group;
    }
    public void setGroup(Group group) {
        this.group = group;
    }  
}

package com.wangwei.hibernate;
import java.util.Date;
public class Group {
private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

②.实体对象的xml配置

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wangwei.hibernate.Group" table="t_group">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wangwei.hibernate.User" table="t_user">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <many-to-one name="group" column="groupid" cascade="save-update"/>
    </class>
</hibernate-mapping>

备注：

在多的一端采用如下标签映射：

<many-to-one name="group" column="groupid"/>


③.什么是级联？

级联是对象之间的连锁操作，它只影响添加、删除和修改

cascade表示级联操作：

常见的级联操作类型：级联保存：当一个实体进行保存操作是，级联保存将自动保存与该实体关联的所有实体。这样可以避免手动保存关联实体的麻烦。

级联更新、级联删除、级联刷新（当一个实体执行刷新操作时，级联刷新将自动刷新与该实体关联的所有实体，确保关联实体的数据与数据库中的数据保存一致）。

除了上面的一些操作之外，还可以进行组合如：级联保存更新、级联保存删除等等。

④.生成的表结构

⑤.往表中插入数据

核心代码：

public void saveTest3() {
        Session session =null;
        try {
            session=HibernateUtils.getSession();
            session.beginTransaction();
            Group group=new Group();
            group.setName("廊坊师范学院");
            User user1=new User();
            user1.setName("wangwei");
            user1.setGroup(group);
            User user2=new User();
            user2.setName("lyy");
            user2.setGroup(group);
            session.save(user1);
            session.save(user2);
            //使用了级联特性
            //hibernate会首先保存User的关联对象 Group
            //Group和User都是Persistent状态的对象了
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        }

生成的sql语句

对应表中的数据

⑥.查询数据

核心代码：

public void loadTest1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            User user = (User)session.load(User.class, 1);
            System.out.println("user.name=" + user.getName());
            System.out.println("user.group.name=" + user.getGroup().getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        }

生成的sql语句和打印出的数据

二、一对多映射是什么？

在 Hibernate 中，一对多关联表示一个实体与多个关联实体之间的关系，其中一个实体拥有对多个关联实体的引用。这种关联关系通常使用集合来表示。

在一对多关联中，存在两个实体，即主实体和从实体。主实体拥有对从实体的集合引用，而从实体则包含一个对主实体的引用。

1.案例：现在有两个实体Classes实体和Student，其中一个班级包含多个学生，表现出一对多的关系。

①实体结构

package com.wangwei.hibernate;
import java.util.Set;
public class Classes {
    private int id;
    private String name;
    private Set students;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set getStudents() {
        return students;
    }
    public void setStudents(Set students) {
        this.students = students;
    }
}

package com.wangwei.hibernate;
public class Student {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

②.实体对应的xml配置

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wangwei.hibernate.Student" table="t_student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wangwei.hibernate.Classes" table="t_classes">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="students">
            <!-- 
            <key column="classesid" not-null="true"/>
             -->
             <key column="classesid"/>
            <one-to-many class="com.wangwei.hibernate.Student"/>
        </set>
    </class>
</hibernate-mapping>

③.生成的表结构

④.插入数据

核心代码：

public void testSave2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student1 = new Student();
            student1.setName("张三");
            session.save(student1);
            Student student2 = new Student();
            student2.setName("李四");
            session.save(student2);
            Classes classes = new Classes();
            classes.setName("计算机");
            Set students = new HashSet();
            students.add(student1);
            students.add(student2);
            classes.setStudents(students);
            //可以成功保存数据
            //但是会发出多余的update语句来维持关系
            session.save(classes);
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

发出的sql语句：

对应数据表中的数据：

⑤.查询数据

核心代码：

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);
        }
    }

发出的sql语句和打印出的内容：

总结

  1. 一对多关联映射和多对一关联映射映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。
  2. 与多对一不同的是，一对多维护的关系是：有一的一端维护关系，一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。

  4. 但是一的一端维护关系存在缺陷：
  5. 因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）
  6. 所以在保存Student的时候关系字段classesid是为null的，如果将该关系字段设置为非空，则
  7. 将无法保存数据

  9. 另外因为Student不维护关系，而Classes维护关系，Classes就会发出多余的update语句，保证
  10. Classes和Student有关系，这样加载Classes的时候才可以把该Classes对应的学生加载上来。发出多余的update语句本身效率上还是有些问题的。
文章标签：
GPU云服务器
Java
SQL
Spring
数据格式
数据库
XML
数据库连接
关键词：
Hibernate框架
Hibernate映射
Hibernate多对一一对多
Hibernate框架多对一
相关实践学习
部署Stable Diffusion玩转AI绘画（GPU云服务器）
本实验通过在ECS上从零开始部署Stable Diffusion来进行AI绘画创作，开启AIGC盲盒。
王卫
目录
相关文章
蓝易云
|
1月前
|
缓存 Java 数据库连接
Hibernate：Java持久层框架的高效应用
通过上述步骤，可以在Java项目中高效应用Hibernate框架，实现对关系数据库的透明持久化管理。Hibernate提供的强大功能和灵活配置，使得开发者能够专注于业务逻辑的实现，而不必过多关注底层数据库操作。
蓝易云
19 1
土木林森
|
3月前
|
Java 数据库连接 API
解锁高效开发秘籍：深入探究 Hibernate 如何优雅处理一对多与多对多关系，让数据映射再无烦恼！
【9月更文挑战第3天】Hibernate 是 Java 领域中最流行的 ORM 框架之一，广泛用于处理实体对象与数据库表之间的映射。尤其在处理复杂关系如一对多和多对多时，Hibernate 提供了丰富的 API 和配置选项。本文通过具体代码示例，展示如何使用 `@OneToMany`、`@JoinColumn`、`@ManyToMany` 和 `@JoinTable` 等注解优雅地实现这些关系，帮助开发者保持代码简洁的同时确保数据一致性。
土木林森
65 4
众所周知
|
4月前
|
SQL Java 数据库连接
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。通过映射机制，它可以自动处理对象与数据库表之间的转换，支持主流数据库，提高了代码的可移植性和可维护性。其核心接口包括 SessionFactory、Session 和 Transaction 等，通过它们可以执行数据库的 CRUD 操作。配置方面，需在项目中引入 Hibernate 及数据库驱动依赖，并创建 `hibernate.cfg.xml` 配置文件来设置数据库连接和 Hibernate 行为参数。
众所周知
62 1
土木林森
|
4月前
|
Java 数据库连接 数据库
AI 时代风起云涌，Hibernate 实体映射引领数据库高效之路，最佳实践与陷阱全解析！
【8月更文挑战第31天】Hibernate 是一款强大的 Java 持久化框架，可将 Java 对象映射到关系数据库表中。本文通过代码示例详细介绍了 Hibernate 实体映射的最佳实践，包括合理使用关联映射（如 `@OneToMany` 和 `@ManyToOne`）以及正确处理继承关系（如单表继承）。此外，还探讨了常见陷阱，例如循环依赖可能导致的无限递归问题，并提供了使用 `@JsonIgnore` 等注解来避免此类问题的方法。通过遵循这些最佳实践，可以显著提升开发效率和数据库操作性能。
土木林森
91 0
土木林森
|
4月前
|
数据库 开发者 Java
Hibernate映射注解的魔力：实体类配置的革命，让你的代码量瞬间蒸发！
【8月更文挑战第31天】Hibernate 是一款出色的对象关系映射框架，简化了 Java 应用与数据库的交互。其映射注解让实体类配置变得直观简洁。本文深入剖析核心概念与使用技巧，通过示例展示如何简化配置。
土木林森
55 0
土木林森
|
4月前
|
数据库 Java 数据库连接
Struts 2 与 Hibernate 的完美邂逅：如何无缝集成两大框架，轻松玩转高效 CRUD 操作？
【8月更文挑战第31天】本文通过具体示例介绍了如何在 Struts 2 中整合 Hibernate，实现基本的 CRUD 操作。首先创建 Maven 项目并添加相关依赖，接着配置 Hibernate 并定义实体类及其映射文件。然后创建 DAO 接口及实现类处理数据库操作，再通过 Struts 2 的 Action 类处理用户请求。最后配置 `struts.xml` 文件并创建 JSP 页面展示用户列表及编辑表单。此示例展示了如何配置和使用这两个框架，使代码更加模块化和可维护。
土木林森
150 0
杰哥在此
|
5月前
|
SQL Java 数据库连接
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
杰哥在此
91 0
土木林森
|
6月前
|
Java 数据库连接 数据库
探索JPA生态：Hibernate与其他ORM框架的对比分析
【6月更文挑战第25天】**JPA标准下的Hibernate是流行的ORM实现，提供丰富功能如二级缓存和延迟加载，但其学习曲线较陡，性能优化复杂。相比如MyBatis，Hibernate的JPQL更面向对象，MyBatis则接近SQL。选择ORM需考虑项目需求和个人偏好。**
土木林森
99 0
学编程的小程
|
7月前
|
SQL 缓存 Java
框架分析（9）-Hibernate
框架分析（9）-Hibernate
学编程的小程
77 2
杨校
|
6月前
|
Java 数据库连接
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨校
37 0