[spring] Spring JPA - Hibernate 多表联查 3

最新推荐文章于 2025-07-03 09:50:45 发布
最新推荐文章于 2025-07-03 09:50:45 发布
阅读量978 收藏 8
点赞数 16
CC 4.0 BY-SA版权
分类专栏： Spring 文章标签： spring hibernate 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42938619/article/details/146463970

[spring] Spring JPA - Hibernate 多表联查 3

这篇笔记基于：

进行实现

这是目前对于 Hibernate 学习的最后一步了，主要学习一下 many-to-many 的关系

之前的内容都覆盖的差不多了，整体来说这篇笔记会比较短，也没这么多代码

Many to Many

many-to-many 应该是日常生活中遇到的最多的情况，如 course <-> student，但是在这种情况下，如果需要使用外链去存储对应的关系，那么就会让数据变得非常难以管理，并且搜索的效率也会非常的低下。

目前比较常见的一个处理方法是使用 join table，去单独存储二者之间的 mapping

更新数据库

DROP SCHEMA IF EXISTS `hb-05-many-to-many`;

CREATE SCHEMA `hb-05-many-to-many`;

use `hb-05-many-to-many`;

SET FOREIGN_KEY_CHECKS = 0;

CREATE TABLE `instructor_detail` (
  `id` int NOT NULL AUTO_INCREMENT,
  `youtube_channel` varchar(128) DEFAULT NULL,
  `hobby` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;


CREATE TABLE `instructor` (
  `id` int NOT NULL AUTO_INCREMENT,
  `first_name` varchar(45) DEFAULT NULL,
  `last_name` varchar(45) DEFAULT NULL,
  `email` varchar(45) DEFAULT NULL,
  `instructor_detail_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_DETAIL_idx` (`instructor_detail_id`),
  CONSTRAINT `FK_DETAIL` FOREIGN KEY (`instructor_detail_id`)
  REFERENCES `instructor_detail` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;


CREATE TABLE `course` (
  `id` int NOT NULL AUTO_INCREMENT,
  `title` varchar(128) DEFAULT NULL,
  `instructor_id` int DEFAULT NULL,

  PRIMARY KEY (`id`),

  UNIQUE KEY `TITLE_UNIQUE` (`title`),

  KEY `FK_INSTRUCTOR_idx` (`instructor_id`),

  CONSTRAINT `FK_INSTRUCTOR`
  FOREIGN KEY (`instructor_id`)
  REFERENCES `instructor` (`id`)

  ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=latin1;


CREATE TABLE `review` (
  `id` int NOT NULL AUTO_INCREMENT,
  `comment` varchar(256) DEFAULT NULL,
  `course_id` int DEFAULT NULL,

  PRIMARY KEY (`id`),

  KEY `FK_COURSE_ID_idx` (`course_id`),

  CONSTRAINT `FK_COURSE`
  FOREIGN KEY (`course_id`)
  REFERENCES `course` (`id`)

  ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;


CREATE TABLE `student` (
  `id` int NOT NULL AUTO_INCREMENT,
  `first_name` varchar(45) DEFAULT NULL,
  `last_name` varchar(45) DEFAULT NULL,
  `email` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;


CREATE TABLE `course_student` (
  `course_id` int NOT NULL,
  `student_id` int NOT NULL,

  PRIMARY KEY (`course_id`,`student_id`),

  KEY `FK_STUDENT_idx` (`student_id`),

  CONSTRAINT `FK_COURSE_05` FOREIGN KEY (`course_id`)
  REFERENCES `course` (`id`)
  ON DELETE NO ACTION ON UPDATE NO ACTION,

  CONSTRAINT `FK_STUDENT` FOREIGN KEY (`student_id`)
  REFERENCES `student` (`id`)
  ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

SET FOREIGN_KEY_CHECKS = 1;

跑完后的结果应该是这样的：

在这里插入图片描述

下面一排和之前的案例是一样的，这里就是新增了两张表格

实现学生实例 & 更新课程实例

简单的代码，写了蛮多遍了：

package com.example.demo.entity;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "student")
@Data
@NoArgsConstructor
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    public Student(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

下面是实现 many-to-many 的部分

更新课程 entity 获取学生
    @JoinTable(
            name = "course_student",
            joinColumns = @JoinColumn(name = "course_id"),
            inverseJoinColumns = @JoinColumn(name = "student_id")
    )
    private List<Student> students;

这个部分理解起来还是比较简单的：

  • JoinTable - 顾名思义，联表
  • joinColumns - 指的是当前 entity 在表中对应的 id
  • inverseJoinColumns - 目标 entity 的 id
更新学生 entity 获取课程
    @ManyToMany(fetch = FetchType.LAZY,
            cascade = { CascadeType.PERSIST, CascadeType.DETACH,
                    CascadeType.MERGE, CascadeType.REFRESH })
    @JoinTable(
            name = "course_student",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;

student 和 course 的实现基本是一致的，但是因为 entity 的不同，所以 joinColumns 和 inverseJoinColumns 所 mapping 的值需要进行对调

更新 main
	private void createCourseAndStudents(AppDAO appDAO) {
		Course course = new Course("Table Tennis");
		Student student1 = new Student("John", "Doe", "john_doe@gmail.com");
		Student student2 = new Student("Mary", "Jane", "m_jane@gmail.com");

		course.addStudent(student1);
		course.addStudent(student2);

		System.out.println("Saving the course: " + course);
		System.out.println("associated students: " + course.getStudents());

		appDAO.save(course);
	}

这个写的应该也是蛮多了，没什么特别大的差异，主要就是跑一下证明一下代码没写错

效果如下：

在这里插入图片描述

寻找上 A 课的学生

这里最关键的是 courseId，找的是所有注册 :course_id 的课

DAOImpl 的实现：

    @Override
    public Course findCourseAndStudentByCourseId(int id) {
        TypedQuery<Course> query = entityManager.createQuery(
                "select c from Course c "
                        + "JOIN FETCH c.students "
                        + "where c.id = :data",
                Course.class
        );

        query.setParameter("data", id);

        return query.getSingleResult();
    }

main 的更新：

	private void findCourseAndStudents(AppDAO appDAO) {
		int id = 10;
		Course course = appDAO.findCourseAndStudentByCourseId(id);

		System.out.println(course);
	}

效果如下：

在这里插入图片描述

找 B 学生要上的所有课

这里最关键的是 studentId，找的是所有注册 :student_id 的课

DAOImpl 的实现如下：

    @Override
    public Student findStudentAndCoursesByStudentId(int id) {
        TypedQuery<Student> query = entityManager.createQuery(
                "select s from Student s "
                        + "JOIN FETCH s.courses "
                        + "where s.id = :data",
                Student.class
        );

        query.setParameter("data", id);

        return query.getSingleResult();
    }

main 的更新如下：

	private void findStudentAndCourses(AppDAO appDAO) {
		int id = 1;
		Student student = appDAO.findStudentAndCoursesByStudentId(id);

		System.out.println(student);
		System.out.println(student.getCourses());
	}

效果截图：

在这里插入图片描述

删除课程

这部分的代码其实没必要变动，一样可以跑：

在这里插入图片描述

主要还是因为 cascade type 里面没有什么 delete 的关系

删除学生

    @Override
    @Transactional
    public void deleteStydentById(int id) {
        Student student = entityManager.find(Student.class, id);

        if (student != null) {
            entityManager.remove(student);
        }
    }

在 remove 之前调用一下 clear 也可以手动断开所有的 foreign key 关联。一般来说 map 的比较好的，JPA 可以自动进行清理——也就是 demo app 跑的

但是如果是要用在 production 上的话，还是加一个 student.getCourses().clear(); 比较好

[中级]SpringBoot JPA 单/多表联合查询
私信可回答各种问题~
09-30 5039
SpringBoot JPA 单/多表联合查询
jpa多表联查动态_Spring Data JPA 实现多表关联查询
weixin_39655377的博客
12-21 426
最近抽出时间来做博客，数据库操作使用的是JPA，相对比 Mybatis 而言，JPA单表操作非常方便，增删改查都已经写好了。但是多表操作就不如 Mybatis 那种直接写 sql 语句来得方便，JPA的多表操作比较麻烦。需求描述获得文章列表，文章列表里需要显示每篇文章的分类目录列表，因为一个文章可能有多个分类，一个分类当然也可以对应多篇文章的。下面是我用截图软件画的一个图，描述的是三张表和其...
基于JPA实现多表连接查询
weixin_44157608的博客
08-21 7534
基于 JPA 显示城市信息一、JPAJPA 定义二、任务实战1.项目结构2.项目配置信息3.实体4.映射5.控制器6.UI三、效果图 一、JPA JPA 定义 Java 持久化 API Java 官方定义的 ORM 规范，只是一套规范，并没有提供底层的实现（基于抽象工厂设计模式，将定义与实现解耦），Hibernate 、TopLink 都是 JPA 的提供商，它们实现了 JPA 规范 JPA 基于注解的方式实现了 实体类 到 关系表 之间的映射 @Entity @Table @Id @Column @O
Spring Data JPA 的多表联合查询, 丰富的实例演示
最新发布
2404_87285359的博客
07-03 1463
一. 简单复习数据库表之间的关系对于JPA的基本操作以及动态查询可以查看这篇文章:目前市场上对于ORM框架选型一般只有两种, 一种是, 另一种就是之前参与的项目都是使用MybatisPlus没有系统的了解JPA, 而到新的项目组中使用的是JPA正当学习时发现网络上对于JPA的文章纷繁杂乱, 尤其是对JPA多表联查使我看的摸不到头脑, 所以本着方便自己日后学习以及分享开发经验的出发点, 写下这篇文章.Mysql版本: Mysql8.0一. 简单复习数据库表之间的关系表之间存在哪几种关系?
Spring Data JPA实现多表的关联查询
热门推荐
pan_junbiao的博客
04-05 2万+
1、Spring Data JPA关系映射 对象关系映射（Object relational mapping）是指通过将对象状态映射到数据库列，来开发和维护对象和关系数据库之间的关系。它能够轻松处理（执行）各种数据库操作，如插入、更新、删除等。 关系映射的注解： 注解 说明 @JoinColumn 指定一个实体组织或实体集合。用在“多对一”和“一对多”的关联中。 @One...
JPA多表查询
m0_50272029的博客
09-06 901
结果集接口方法更灵活，可以通过自定义的查询结果接口来选择需要返回的字段。关联映射方法更方便管理关系，可以直接在实体类中通过@ManyToOne或@OneToMany等注解来实现关联查询。这两种方式在不同的场景下各有优势，具体选择哪种方式取决于项目的需求。
【jpa实现多表查询】
weixin_44103060的博客
10-28 2783
jpa多表关联查询
spring-boot-jpa-hibernate：这是将Hibernate与Spring Boot应用程序集成的非常简单的指南
02-04
在提供的压缩包文件"spring-boot-jpa-hibernate-master"中，可能包含了完整的示例项目，包括源代码、配置文件和README文档。通过阅读源代码，你可以更深入地理解上述概念，并学习如何实际应用它们。 总结起来，整合...
Spring-Boot-JPA-Hibernate-Query-Methods:Spring Boot JPAHibernate查询方法
04-04
Spring Boot JPAHibernate查询方法 Spring Data JPA是提供各种API来执行CRUD操作的Spring Data模块之一.Spring Data JPA主要用于存储库层的开发。 在Spring Data中，我们可以定义存储库接口和方法来检索数据。 所有...
Gradle-Spring4-JPA-Hibernate4-WebTemplate:使用带有 Spring-Core、Spring-MVC、Spring-JPA、Hibernate4 和 Annotations 配置的 Gradle 结构的模板 Web 项目
07-09
Gradle-Spring4-JPA-Hibernate4-WebTemplate 模板 Web 项目使用带有 Spring-Core、Spring-MVC、Spring-JPA、Hibernate4 和 Annotations 配置的 Gradle 结构。
Spring-Data-JPA-using-Hibernate:使用Hibernate eclipse项目的Spring Data JPA
03-15
3. **Spring Data JPA与Hibernate的整合** - 配置：在`pom.xml`中添加Spring Data JPA和Hibernate的依赖，确保版本兼容。 - `persistence.xml`：配置JPA供应商为Hibernate，包括数据库连接信息、实体管理工厂和JPA...
spring-jpa-hibernate-one-to-many-example:使用MySql中的Spring JPA的Hibernate中的OneToMany映射示例
05-17
使用MySql示例的带有Hibernate的Spring Data JPA 该项目使用MySql Example描述了带有Spring Data JPA和Hibernate的Spring Boot示例。 描述 该项目显示了存储在MySql数据库中的用户列表。 使用以下端点，可以实现...
Hibernate连表查询 Hibernate连表查询
01-13
Hibernate连表查询 Hibernate连表查询
Spring Data JPA 多表关联查询的实现
结缘缘的博客
07-20 3016
Spring Data JPA 多表关联查询的实现
jpa 多表关联查询
srj904711648的博客
03-02 2655
jpa 多表关联查询
Spring Data JPA 实现多表关联查询
wml00000的博客
04-22 1万+
原文链接：https://blog.csdn.net/johnf_nash/article/details/80587204 多表查询在spring data jpa中有两种实现方式，第一种是利用hibernate的级联查询来实现，第二种是创建一个结果集的接口来接收连表查询后的结果，这里介绍第二种方式。 一、一对一映射 实体 UserInfo ：用户。 实体 Address：家庭住址。 这里通过外键的方式(一个实体通过外键关联到另一个实体的主键)来实现一对一关联。 实体类 1、实体类 UserInfo.ja
springJPA多表联查
zy19960902的博客
11-24 564
https://blog.csdn.net/u011857433/article/details/80184757#springboot%E4%B8%ADjpa%E5%A4%9A%E8%A1%A8%E8%81%94%E5%90%88%E8%87%AA%E5%AE%9A%E4%B9%89%E6%9F%A5%E8%AF%A2query https://blog.csdn.net/qq_3614425...
使用jpa进行多表联查、分页
weixin_69411453的博客
11-14 1490
首先dao层mapper继承。
Spring3 MVC与Hibernate-JPA集成Eclipse演示项目
1. 示例代码的重要性与问题：在学习SpringMVC和Hibernate-JPA时，虽然网络上有许多示例代码，但往往存在不全面或有缺陷的问题，容易造成学习者误区。该示例的目的在于提供一个经过实际测试并修正了已知bug的代码，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值