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

最新推荐文章于 2025-07-03 09:50:45 发布
原创 最新推荐文章于 2025-07-03 09:50:45 发布 · 675 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #hibernate #数据库

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

这篇笔记基于 [spring] Spring JPA - Hibernate 多表联查 1 之上进行的实现，主要的 skeleton 都在那里了，代码不一定会全部 cv

这篇主要实现的是 one-to-many 和 many-to-one 的关系。这个实现起来和上一篇里用 @OneToOne 以及 @OneToOne(mappedBy) 的方向是一致的，同样是一个表里设有 foreign key（一半在 many 的那个实例中），另一个没有 foreign key 的通过 mappedBy 去做 join 搜索

one to many & many to one

这次新增的实例为 course，这里的逻辑一个老师可以很多课——这里不考虑同一个课会被多个老师教，即不同 section 的条件

⚠️：不需要使用 cascading delete，即删除老师不需要联动删除课程，反之亦然

具体图如下：
instructor
course1
course2
course3

⚠️：这会是一个 bi-directional 的关系

更新数据库

这里也同样提供 sql：

DROP SCHEMA IF EXISTS `hb-03-one-to-many`;

CREATE SCHEMA `hb-03-one-to-many`;

use `hb-03-one-to-many`;

SET FOREIGN_KEY_CHECKS = 0;

DROP TABLE IF EXISTS `instructor_detail`;

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;


DROP TABLE IF EXISTS `instructor`;

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;

DROP TABLE IF EXISTS `course`;

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;


SET FOREIGN_KEY_CHECKS = 1;

运行后的结果应该如下：

在这里插入图片描述

⚠️：如果 spring boot 遇到了连接问题，可以查看 [spring] Spring JPA - Hibernate 多表联查 1 中的 reference 部分解决

代码设置

实现 Course Entity
package com.example.demo.entity;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.hibernate.annotations.Cascade;

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

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

    @ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.DETACH,
                            CascadeType.MERGE, CascadeType.REFRESH })
    @JoinColumn(name = "instructor_id")
    private Instructor instructor;

    public Course(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", title='" + title + '\'' +
                '}';
    }
}

⚠️：instructor-to-course 是 one-to-many 的关系，正常情况下是将 foreign key 放到 many 的这个部分——这个案例中也就是 course 里，所以这里才会用 @JoinColumn(name = "instructor_id")

更新 instructor entity
package com.example.demo.entity;

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

import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "instructor")
@Data
@NoArgsConstructor
public class Instructor {
    @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;

    // set up mapping to InstructDetail
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "instructor_detail_id")
    private InstructorDetail instructorDetail;

    @OneToMany(mappedBy = "instructor",
                cascade = { CascadeType.PERSIST, CascadeType.DETACH,
                            CascadeType.MERGE, CascadeType.REFRESH })
    private List<Course> courses;

    public Instructor(String firstname, String lastname, String email) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Instructor{" +
                "instructorDetail=" + instructorDetail +
                ", email='" + email + '\'' +
                ", lastname='" + lastname + '\'' +
                ", firstname='" + firstname + '\'' +
                ", id=" + id +
                '}';
    }

    // add convenience methods for bi-directional relationship
    public void add(Course course) {
        if (courses == null) {
            courses = new ArrayList<>();
        }

        courses.add(course);

        course.setInstructor(this);
    }
}

⚠️：这里主要更新的部分是 private List<Course> courses; 以及其对应的注解，在上面的图解中已经表明了，一个老师可以上好几门课，所以这里需要用一个 List 去存储对应的数据

👀：这里新增了一个 util 方法，即 public void add(Course course) ，主要是可以方便的添加课程

update properties file

主要是需要更新一下数据库相关的部分，也就是 datasource.url

spring.datasource.url=jdbc:mysql://localhost:3306/hb-01-one-to-one-uni

添加有课的老师

这里主要更新的是 cli 部分的代码：

	private void createInstructorWithCourses(AppDAO appDAO) {
		// create the instructor
		Instructor instructor = new Instructor("Peter", "Parker", "peter.p@gmail.com");
		InstructorDetail instructorDetail = new InstructorDetail("http://www.example.com", "Piano");
		Course course1 = new Course("Guitar");
		Course course2 = new Course("Paint ball");

		// associate the objects
		instructor.setInstructorDetail(instructorDetail);
		instructor.add(course1);
		instructor.add(course2);

		System.out.println("Saving instructor: " + instructor);
		System.out.println("Courses: " + instructor.getCourses());
		appDAO.save(instructor);

		System.out.println("Done!");
	}

效果如下：

在这里插入图片描述

在这里插入图片描述

fetch 类型

上篇有简单的题过 fetch 的类型分为 eager 和 lazy 两种，二者的区别如下：

  • eager 会获取所有的关联实例

    以当前案例来说，在获取 instructor 的数据后，它同时会获取所有关联的 courses

    当存在多个 instructors 的情况下，这就类似于执行了下面这个 query：

    SELECT * FROM instructor;

SELECT * FROM course WHERE instructor_id = 1;
SELECT * FROM course WHERE instructor_id = 2;
SELECT * FROM course WHERE instructor_id = 3;

    这也就遇到了比较经典的 N+1 query 问题——即获取 1 次 instructors 数据，同时调用 instructors 长度（N）个 query 去获取关联的数据

    💡：这种情况下，要做优化的话可以通过 @Query("SELECT i FROM Instructor i JOIN FETCH i.courses") 去获取整个 instructor list，或者通过 @EntityGraph 去进行优化

  • lazy 默认情况下不会获取相关联的数据，只有在调用/访问对应的属性/getter 时，才会去重新通过 query 获取对应的数据

    ⚠️：@OneToMany 的默认 FetchType 是 lazy

    一般来说这种实现更好，不过它也会存在两个问题：

    1. 需要一个打开的 hibernate session

      这个情况下来说，发生在当前方法已经返回了 instructor，然后 hibernate session 关闭。其他的方法——在非 @Transactional 的方法中去访问 instructor 中的 courses，就会抛出异常

      触发方式如下：

      更新 main 中的代码：

      private void findInstructorWithCourses(AppDAO appDAO) {
    int id = 1;
    System.out.println("Finding instructor id: " + id);

    Instructor instructor = appDAO.findInstructorById(id);
    System.out.println("instructor: " + instructor);
    System.out.println("associated courses:" + instructor.getCourses());
}

      这是在 main 方法内调用的，hibernate session 已经关闭。默认情况下是进行 lazy fetch，所以 instructor 相关联的 course 也不会被获取

      这个时候就会触发报错：

      在这里插入图片描述

      这个时候只要将 FetchType 改成 eager：

      @OneToMany(mappedBy = "instructor",
            fetch = FetchType.EAGER,
            cascade = { CascadeType.PERSIST, CascadeType.DETACH,
                        CascadeType.MERGE, CascadeType.REFRESH })
private List<Course> courses;

      那么数据就会正常渲染：

      在这里插入图片描述

    2. 在 @Transactional 的方法中去循环访问每个 instructor 的 courses

      这个依旧是会造成 n+1 query 的问题

    一般来说，常见的处理方式是在 entity 中，使用 Lazy 注解，这样调用 findAll() 只会跑一条 query；同时也可以新增加一个方法，通过上面的 @Query 去实现 List<Instructor> findAllWithCourses(); 这样的方法，也能够有效地减缓数据库的调用

Lazy Fetch 的使用案例

这里会将 instructor 中的 course 获取方式设置成 lazy——即默认情况

@OneToMany(mappedBy = "instructor",
            fetch = FetchType.LAZY,
            cascade = { CascadeType.PERSIST, CascadeType.DETACH,
                        CascadeType.MERGE, CascadeType.REFRESH })
private List<Course> courses;
直接通过 foreign key 获取

首先，因为 foreign key 设置在 course 上，所以可以直接通过 FK 去寻找一个 instructor 教的所有课，案例如下：

  1. 新增加一个方法获取 instructor

    public interface AppDAO {

    List<Course> findCoursesByInstructorId(int id);
}


    @Override
public List<Course> findCoursesByInstructorId(int id) {
    TypedQuery<Course> query = entityManager.createQuery(
                                "from Course where instructor.id = :data", Course.class);
    query.setParameter("data", id);

    return query.getResultList();
}

  2. 使用新的方法

    private void findCoursesForInstructor(AppDAO appDAO) {
    int id = 1;
    System.out.println("finding instructor id: " + id);

    Instructor instructor = appDAO.findInstructorById(id);
    System.out.println("instructor: " + instructor);

    // retrieve courses for the instructor
    System.out.println("finding courses for instructor id: " + id);
    List<Course> courses = appDAO.findCoursesByInstructorId(id);
    instructor.setCourses(courses);
    System.out.println("associated courses: " + instructor.getCourses());

    System.out.println("Done");
}

  3. 结果：

    在这里插入图片描述

join fetch

也就是上面提到的常见解决方法

这里新增加一个方法获取 instructor

    public Instructor findInstructorByIdJoinFetch(int id) {
        return null;
    }    @Override
    public Instructor findInstructorByIdJoinFetch(int id) {
        TypedQuery<Instructor> query = entityManager.createQuery(
                                        "select i from Instructor i "
                                        + "JOIN FETCH i.courses "
                                        + "where i.id = :data", Instructor.class);
        query.setParameter("data", id);

        return query.getSingleResult();
    }

    private void findInstructorWithCoursesJoinFetch(AppDAO appDAO) {
    	int id = 1;
    	System.out.println("finding instructor id: " + id);

    	Instructor instructor = appDAO.findInstructorByIdJoinFetch(id);
    	System.out.println(instructor);
    	System.out.println("associated courses: " + instructor.getCourses());
    	System.out.println("Done");
    }

调用结果如下：

在这里插入图片描述

更新实例（Update 操作）

更新 instructor

这里通过 merge 实现，代码修改如下：

    void update(Instructor instructor);

    @Override
    @Transactional
    public void update(Instructor instructor) {
        entityManager.merge(instructor);
    }

	private void updateInstructor(AppDAO appDAO) {
		int id = 1;

		System.out.println("Finding instructor id: " + id);
		Instructor instructor = appDAO.findInstructorByIdJoinFetch(id);

		System.out.println("Updating instructor id: " + id);
		instructor.setLastname("TESTER");

		appDAO.update(instructor);

		System.out.println("Done");
	}

效果：

在这里插入图片描述

前后
在这里插入图片描述在这里插入图片描述
更新 course

核心逻辑是一样的

    Course findCourseById(int id);

    void update(Course course);

    @Override
    public Course findCourseById(int id) {
        return entityManager.find(Course.class, id);
    }

    @Override
    @Transactional
    public void update(Course course) {
        entityManager.merge(course);
    }

	private void updateCourse(AppDAO appDAO) {
		int id = 10;

		System.out.println("Finding course id: " + id);
		Course course = appDAO.findCourseById(id);

		System.out.println("Updating course id: " + id);
		course.setTitle("New Course");
		appDAO.update(course);
	}

在这里插入图片描述

前后对比：

前后
在这里插入图片描述在这里插入图片描述

复习一下 merge 的操作：

会将 detached entity 的变更数据 复制到当前 管理中的 entity。如果数据库中已有该 entity，则会 更新 现有记录；如果没有，则会 插入 新记录

更新删除实例

这里主要的操作就是将所有的 course 删除掉，否则会有 foreign key constraint 的问题

    @Override
    @Transactional
    public void deleteInstructorById(int id) {
        Instructor instructor = this.findInstructorById(id);

        if (instructor != null) {
            List<Course> courses = instructor.getCourses();

            for (Course course : courses) {
                course.setInstructor(null);
            }

            entityManager.remove(instructor);
        }
    }

这里还是 n+1 query 的操作，可以通过手写一些 query 去提升效果

新增 uni-directional 的 Review 实例

这个基本上就是把东西重复一下，练一下手

主要 course --> review 是一个单方面的，one-to-many 的关系。当然，具体实现也是根据之前说的，在 many 的实例上设置 foreign key

数据库修改

sql 脚本如下：

DROP SCHEMA IF EXISTS `hb-04-one-to-many-uni`;

CREATE SCHEMA `hb-04-one-to-many-uni`;

use `hb-04-one-to-many-uni`;

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;


SET FOREIGN_KEY_CHECKS = 1;

在这里插入图片描述

实现 review 实例

代码基本上一致，

package com.example.demo.entity;

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

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

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

    public Review(String comment) {
        this.comment = comment;
    }

    @Override
    public String toString() {
        return "Review{" +
                "id=" + id +
                ", comment='" + comment + '\'' +
                '}';
    }
}

⚠️：这里 review 并没有和 course 建立任何关系，所以是 course --> review 的单方面联系

重构 course

如上面提到的，新增 one-to-many 的关系

public class Course {
    //...

    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name = "course_id")
    private List<Review> reviews;

    //...

    public void addReview(Review review) {
        if (reviews == null) {
            reviews = new ArrayList<>();
        }

        reviews.add(review);
    }
}
更新 DAO 和 main

这里就基本还是那几个变化了：

    @Override
    @Transactional
    public void save(Course course) {
        entityManager.persist(course);
    }

	private void createCourseAndReviews(AppDAO appDAO) {
		Course course = new Course("Minesweeper");

		course.addReview(new Review("Finish advanced level in 100s!"));
		course.addReview(new Review("Great course!"));
		course.addReview(new Review("Love it!"));
		course.addReview(new Review("Average..."));

		System.out.println("Saving the course...");
		System.out.println(course);
		System.out.println(course.getReviews());

		appDAO.save(course);
	}

结果如下：

在这里插入图片描述

获取 course 和 review

这里也使用 join 去做搜索

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

        query.setParameter("data", id);

        return query.getSingleResult();
    }
删除 course 和 review

这个实现更简单了，因为有 cascading delete，所以直接删即可

	private void deleteCourseAndReviews(AppDAO appDAO) {
		int id = 10;

		System.out.println("Deleting course id: " + id);
		appDAO.deleteCourseById(id);
	}
Java 里 Hibernate 的多表关联查询实战
AI开发架构师
05-11 1197
本文旨在为 Java 开发者提供全面的 Hibernate 多表关联查询实战指南。实体间的各种关联关系映射不同查询方式的实现和比较关联查询的性能优化策略N+1 查询问题的解决方案复杂查询的构建技巧首先介绍 Hibernate 多表关联的基本概念和类型然后详细讲解各种关联映射的实现方式接着探讨不同查询方法的具体应用最后分析性能优化策略和实际应用案例: 对象关系映射，一种将面向对象语言中的对象与关系数据库中的表进行转换的技术实体(Entity)
使用jpa进行多表联查、分页
weixin_69411453的博客
11-14 1489
首先dao层mapper继承。
[spring] Spring JPA - Hibernate 多表联查 1
GoldenaArcher的博客
03-18 1132
之前在和简单的学习了一下怎么使用 Hibernate 实现 CRUD 操作，不过涉及到的部分都是逻辑上比较简单的实现——只在一张表上进行操作关于多表关联的部分，只是在关键字中提到了有提到过 Relationship 的注解，之后这两章内容就会对 Relationship 进行学习。
Spring Data JPA 的多表联合查询, 丰富的实例演示
最新发布
2404_87285359的博客
07-03 1408
一. 简单复习数据库表之间的关系对于JPA的基本操作以及动态查询可以查看这篇文章:目前市场上对于ORM框架选型一般只有两种, 一种是, 另一种就是之前参与的项目都是使用MybatisPlus没有系统的了解JPA, 而到新的项目组中使用的是JPA正当学习时发现网络上对于JPA的文章纷繁杂乱, 尤其是对JPA多表联查使我看的摸不到头脑, 所以本着方便自己日后学习以及分享开发经验的出发点, 写下这篇文章.Mysql版本: Mysql8.0一. 简单复习数据库表之间的关系表之间存在哪几种关系?
jpa实现查询
dxjren的博客
12-10 1448
jpa实现：分页、排序、时间段查询、分页查询、模糊查询、精确查询
Spring Data JPA实现多表的关联查询
热门推荐
pan_junbiao的博客
04-05 2万+
1、Spring Data JPA关系映射 对象关系映射（Object relational mapping）是指通过将对象状态映射到数据库列，来开发和维护对象和关系数据库之间的关系。它能够轻松处理（执行）各种数据库操作，如插入、更新、删除等。 关系映射的注解： 注解 说明 @JoinColumn 指定一个实体组织或实体集合。用在“多对一”和“一对多”的关联中。 @One...
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
下面将详细介绍Spring Data JPA与Hibernate的整合，以及如何在Eclipse环境中设置和使用它们。 1. **Spring Data JPA简介** Spring Data JPA是Spring框架的一部分，旨在通过简单的接口定义，减少开发人员编写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数据库中的用户列表。 使用以下端点，可以实现...
[spring] Spring JPA - Hibernate 多表联查 3
GoldenaArcher的博客
03-23 974
进行实现这是目前对于 Hibernate 学习的最后一步了，主要学习一下 many-to-many 的关系之前的内容都覆盖的差不多了，整体来说这篇笔记会比较短，也没这么多代码。
【Hibernate】Hibernate的多表查询
编程记录，亲测有效
06-27 1万+
在《【Hibernate】Hibernate的聚类查询、分组查询、排序与时间之差》（点击打开链接）一文中已经讲述过如何利用HQL语句取代SQL语句，进行聚类查询、分组查询、排序与时间之差的查询，同时指出hql能代替sql语句做任何事情。我原本以为hql语句的多表查询，要先对里面的实体做Java与xml的修改，其实并不需要，同样是一句HQL语句就能搞定的事情。SQL的多表查询已经在《【Mysql】利
hibernate多表联合查询
读书探究世界的博客
06-30 1313
//三表联合查询 /* * select t.* from product t,category c,categorysecond cs WHERE t.csid = cs.csid and c.cid = cs.cid and c.cid = 1 */
java hibernate 联合查询_hibernate实现多表联合查询
weixin_42685438的博客
02-16 1122
以前用sql实现联合查询 是非常简单的事，只需要写sql语句就可以，第一次遇到hibernate要实现多表联合查询的时候还楞了一下。最后看了下资料，才恍然大悟，hibernate实现多表联合查询跟SQL没多大差别。hibernate很多实现都是靠喜欢配关系，但是如果两张表，数据量都非常大的时候，并不合适配关系。例如：student表和score表需要做联合查询。1)sql: selects.id...
hibernate实现多表联合查询
yyyhhh0123的专栏
09-12 581
以前用sql实现联合查询 是非常简单的事，只需要写sql语句就可以，第一次遇到hibernate要实现多表联合查询的时候还楞了一下。最后看了下资料，才恍然大悟，hibernate实现多表联合查询跟SQL没多大差别。 hibernate很多实现都是靠喜欢配关系，但是如果两张表，数据量都非常大的时候，并不合适配关系。 例如：student表和score表需要做联合查询。 ...
Mybatis/Mybatis-plus多表关联分页数目偏小问题
qq_42842433的博客
09-18 733
A表：id，a_name B表：id，b_name ，aid（外键，关联A表id） 若要分页查询A表的a_name，同时要关联查询B表的b_name, 由于A表的一列可能对应多个B表记录，所以若将sql写成A表和B表等值连接，并用collection标签将b_name封装进一个list，将会出现重复列 如下例： aid a_name b_name 1 a1 b1 1 a1 b2 2 a2 b3 3 a3 b4 若此时对结果分页，每页4条记录，实际查询出来只会有3条记录 解决方
JPA多表联查笔记
QinQinSmile的博客
05-10 796
上手难度比较大，首次写需好好了解(root, query, builder) Specification<Object1> cation = (root, query, builder) -> { List<Predicate> predicates= new ArrayList<>(); //单个条件 if (StringUtils.hasText(params)) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值