spring data jpa关联查询（一对一、一对多、多对多）

最新推荐文章于 2024-01-07 16:19:19 发布
最新推荐文章于 2024-01-07 16:19:19 发布
阅读量566 收藏 1
点赞数
文章标签： java 开发工具 数据库
原文链接：http://www.cnblogs.com/hhhshct/p/9492741.html
版权

　　在实际过往的项目中，常用的查询操作有：1、单表查询，2、一对一查询（主表和详情表）3、一对多查询（一张主表，多张子表）4、多对多查询（如权限控制，用户、角色多对多）。做个总结，所以废话不多说。

　　使用idea构建springboot项目，引入依赖如下：

dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

　　使用h2数据库做测试用，application.yml配置如下：

spring:
  jpa:
    generate-ddl: true
    hibernate:
      ddl-auto: update
    properties:
      hibenate:
        format_sql: false
    show-sql: true

　　首先，一对一有好几种，这里举例的是常用的一对一双向外键关联（改造成单向很简单，在对应的实体类去掉要关联其它实体的属性即可），并且配置了级联删除和添加，相关类如下：

package io.powerx;

import lombok.*;

import javax.persistence.*;

/**
 * Created by Administrator on 2018/8/15.
 */
@Getter
@Setter
@Entity
public class Book {
    @Id
    @GeneratedValue
    private Integer id;

    private String name;


    @OneToOne(cascade = {CascadeType.PERSIST,CascadeType.REMOVE})
    @JoinColumn(name="detailId",referencedColumnName = "id")
    private BookDetail bookDetail;

    public Book(){
        super();
    }
    public Book(String name){
        super();
        this.name =name;
    }

    public Book(String name, BookDetail bookDetail) {
        super();
        this.name = name;
        this.bookDetail = bookDetail;
    }
    @Override
    public String toString() {
        if (null == bookDetail) {
            return String.format("Book [id=%s, name=%s, number of pages=%s]", id, name, "<EMPTY>");
        }

        return String.format("Book [id=%s, name=%s, number of pages=%s]", id, name, bookDetail.getNumberOfPages());
    }
}
package io.powerx;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;

@Getter
@Setter
@Entity(name = "BOOK_DETAIL")
public class BookDetail {

    @Id
    @GeneratedValue
    private Integer id;

    @Column(name = "NUMBER_OF_PAGES")
    private Integer numberOfPages;

    @OneToOne(mappedBy = "bookDetail")
    private Book book;

    public BookDetail() {
        super();
    }

    public BookDetail(Integer numberOfPages) {
        super();
        this.numberOfPages = numberOfPages;
    }

    @Override
    public String toString() {
        if (null == book) {
            return String.format("Book [id=%s, name=%s, number of pages=%s]", id, "<EMPTY>");
        }

        return String.format("Book [id=%s, name=%s, number of pages=%s]", id,book.getId(),book.getName());
    }
}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Administrator on 2018/8/15.
 */
public interface BookRepository extends JpaRepository<Book,Integer> {
    Book findByName(String name);
}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Administrator on 2018/8/15.
 */
public interface BookDetailRepository  extends JpaRepository<BookDetail, Integer>{

    BookDetail findByNumberOfPages(Integer numberOfPages);
}
package io.powerx;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;

import static org.junit.Assert.assertThat;

@RunWith(SpringRunner.class)
@SpringBootTest
public class OnetooneApplicationTests {

    @Autowired
    private BookRepository bookRepository;

    @Autowired
    private BookDetailRepository bookDetailRepository;

    @Before
    public void init() {
        Book bookA = new Book("Spring in Action", new BookDetail(208));
        Book bookB = new Book("Spring Data in Action", new BookDetail(235));
        Book bookC = new Book("Spring Boot in Action");
        bookRepository.saveAll(Arrays.asList(bookA, bookB, bookC));
    }

    @After
    public void clear() {
        bookRepository.deleteAll();
    }

    @Test
    public void find() {
        Book book = bookRepository.findByName("Spring in Action");
        System.err.println(book.toString());
    }

    @Test
    public void save() {
        Book book = new Book("springboot");
        BookDetail bookDetail = new BookDetail(124);
        book.setBookDetail(bookDetail);
        bookRepository.save(book);
    }

    @Test
    public void delete() {

        bookRepository.deleteById(31);
    }
    @Test
    public void findbook(){
        BookDetail bd = bookDetailRepository.findByNumberOfPages(235);
        System.err.println(bd.toString());

    }
}

　　一对多双向，相关类如下：

package io.powerx;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;

@Getter
@Setter
@Entity
public class Book {
    @Id
    @GeneratedValue
    private Integer id;

    private String name;

    @ManyToOne
    @JoinColumn(name="publishId")
    private Publisher publisher;

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", publisher=" + publisher.getName() +
                '}';
    }

    public Book(String name) {
        this.name = name;
    }

    public Book() {
    }
}
package io.powerx;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by Administrator on 2018/8/16.
 */
@Getter
@Setter
@Entity
public class Publisher {
    @Id
    @GeneratedValue
    private Integer id;

    private String name;

    @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinColumn(name="publishId",referencedColumnName = "id")
    private Set<Book> books;

    public Publisher() {
        super();
    }

    public Publisher(String name) {
        super();
        this.name = name;
    }

    @Override
    public String toString() {
        return "Publisher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", books=" + books.size() +
                '}';
    }

}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Administrator on 2018/8/16.
 */
public interface BookRepository  extends JpaRepository<Book,Integer>{

    Book findByName(String name);

}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Administrator on 2018/8/16.
 */
public interface PublisherRepository extends JpaRepository<Publisher,Integer> {

    Publisher findByName(String name);
}
package io.powerx;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashSet;
import java.util.Set;

@RunWith(SpringRunner.class)
@SpringBootTest
public class OnetomanyApplicationTests {

    @Autowired
    private PublisherRepository publisherRepository;

    @Autowired
    private BookRepository bookRepository;

    @Before
    public void init() {

        Book book1 = new Book("spring");
        Book book2 = new Book("mvc");
        Book book3 = new Book("mybatis");
        Publisher publisher = new Publisher("zhonghua");
        Set<Book> set = new HashSet<Book>();
        set.add(book1);
        set.add(book2);
        set.add(book3);
        publisher.setBooks(set);
        publisherRepository.save(publisher);

    }

    @After
    public void clear() {
        publisherRepository.deleteAll();
    }

    @Test
    public void find() {
        Publisher publisher = publisherRepository.findByName("zhonghua");
        System.out.println(publisher);
    }

    @Test
    public void find2() {
        Book book = bookRepository.findByName("mvc");
        System.out.println(book);
    }
}

　　多对多双向，相关代码如下：

package io.powerx;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;
import java.util.Set;

@Getter
@Setter
@Entity
public class Author {

    @Id
    @GeneratedValue
    private Integer id;

    private String name;

    @ManyToMany(mappedBy = "authors",fetch = FetchType.EAGER)
    private Set<Book> books;

    public Author() {
        super();
    }

    public Author(String name) {
        super();
        this.name = name;
    }

    @Override
    public String toString() {
        return "Author{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", books=" + books.size() +
                '}';
    }
}
package io.powerx;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Getter
@Setter
@Entity
public class Book {

    @Id
    @GeneratedValue
    private Integer id;

    private String name;

    @ManyToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinTable(name = "BOOK_AUTHOR", joinColumns = {
            @JoinColumn(name = "BOOK_ID", referencedColumnName = "ID")}, inverseJoinColumns = {
            @JoinColumn(name = "AUTHOR_ID", referencedColumnName = "ID")})
    private Set<Author> authors;

    public Book() {
        super();
    }

    public Book(String name) {
        super();
        this.name = name;
        this.authors = new HashSet<>();
    }

    public Book(String name, Set<Author> authors) {
        super();
        this.name = name;
        this.authors = authors;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", authors=" + authors.size() +
                '}';
    }
}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface AuthorRepository extends JpaRepository<Author, Integer> {

    Author findByName(String name);

    List<Author> findByNameContaining(String name);

}
package io.powerx;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface BookRepository extends JpaRepository<Book, Integer> {

    Book findByName(String name);

    List<Book> findByNameContaining(String name);

}

　　在调试过程中，注意实体类的tostring方法的重写，避免相互引用；此外如果超过两张表的关联查询，建议使用自定义sql，建立相应的pojo来接收查询结果。

 

转载于:https://www.cnblogs.com/hhhshct/p/9492741.html

weixin_30421809
关注
Spring Data JPA的一对一多表查询
m0_66884848的博客
03-22 6123
一、简单聊聊 我在写自己的课程设计的时候，用的持久层API就是JPA。整个项目给我带来的感受就是：低SQL语句开发，甚至是零SQL语句开发，使得我在开发过程中，不再关注SQL语句的书写问题与逻辑问题。这使得我在开发过程中，更加专注于自己的业务逻辑，而不在拘泥于SQL表和Java实体之间的映射。尤其在多表查询这一块，JPA以其超简洁的语法规则，给我们实现了表一对一乃至一对多的关系。那么今天想给大家分享的是，一对一的多表查询。 二、简单认识JPA 以下引用了网上对JPA的介绍： ...
Spring Data JPA 关联关系查询
SnowMultiflora的博客
11-14 535
目录 一、一对一关联关系 二、一对多关联关系 三、多对多关联关系 四、级联操作 一、一对一关联关系 需求：一个用户(Users)对应一个角色(Roles)，一个角色对应一个用户 用户：一方 角色：一方 我们使用注解@OneToOne表示一对一关系，注解@JoinColumn用来创建外键列（如果我们开启了正向工程），其name值就是外键列的列名。 在注解@OneToOne的括号里...
JPA一对一，一对多，多对多关系映射
05-14
JPA一对一，一对多，多对多关系映射，面向对象领域
JPA学习笔记（9）——映射双向一对一关联关系
君君的专栏
08-15 5285
双向一对一关联关系一个部门有一个经理，一个经理管一个部门Department实体类package com.jpa.helloworld2;import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.
JPA 一对多关联查询
踏雪无痕
03-18 5520
背景说明 本文以用户、订单、订单详情三者之间的关系来详细介绍jpa的功能使用。这个场景也比较符合实际开发中的业务场景。 数据库表 用户表（t_user）,订单表（t_order）,订单详情表（t_order_item） 三张表的结构如下： t_user表 t_order表 t_order_item 注意：三张表如需手动创建，有系统自动创建。 码上开始 这里就不对jpa的一些基本知识展开讲了，不是很清楚的可以自己先学习下jpa基本的知识。 首先准备好基本的实体类。 1. 用户表相关实体类
SpringDataJPA-关联关系查询-创建一对一关联关系
失忆๑的博客
08-21 741
一）SpringData（双向）一对一配置 1.1）使用到的注解 1.@OneToOne：表示一对一的关系 public @interface OneToOne { Class targetEntity() default void.class;//目标实体类 CascadeType[] cascade() default {};//级联策略 FetchType fet...
JPA的一对一、一对多、多对多查询
qq_43975645的博客
07-20 527
因为Blog类中的userId和User类中的id都指向同一个数据库字段，这样就会导致级联更新时重复修改而报错。一对多要相互依赖，首先有多对一，这里Blog类中需要定义一个User，并添加注解。都会将关联的实体类对象包含进去，导致执行查询时循环调用到栈溢出。然后User类中需要定义Blog集合，接收多个Blog对象。区别只是类型是单个对象还是集合对象。在JPA中要慎用，因为重写的。，指定name关联的字段。
Spring Data JPA 实现多表关联查询的示例代码
08-27
在Spring Data JPA中，多表关联查询是一个常见的需求，特别是在复杂的业务场景下。本文将主要探讨通过创建结果集接口的方式来实现多表关联查询的方法，而不是依赖Hibernate的级联查询。 首先，我们要了解Spring ...
Spring Data JPA的优点和难点.pdf
12-05
- 在处理多对一、一对多、多对多等复杂关联关系时，可能会出现懒加载（LazyInitializationException）问题。为了避免这种情况，开发者需要合理设置fetch策略，比如选择eager loading或使用`@Transactional`注解确保...
Spring-Data-Jpa关联查询
m0_68399617的博客
03-20 1660
依照SpringData的命名规则，对于两个有关联关系的对象的查询，可以通过方法名中“_”下划线类标识，也可以通过Spring-Data-Jpa命名规范查询，同时SpringDataJpa还支持用@Query注解定义在数据访问层接口的方法上实现查询，下面来看一个示例进行理解。 上一篇讲了Spring-Data-Jpa入门，这一篇来看一下Spring-Data-Jpa条件查询（基于上一篇Spring-Data-Jpa入门的项目中写的，配置文件没有任何改动，详情可以参考Spring-Data-Jpa入门）。 .
JPA中的一对一双向关联
04-05
NULL 博文链接：https://1028826685.iteye.com/blog/1525683
Spring Data JPA 一对一 聚合查询
ww702109k的博客
06-06 956
JPA 一对一 聚合查询
从零开始 Spring Boot 56：JPA中的一对一关系
梦幻天空
07-03 710
这篇文章将介绍如何在 JPA（Hibernate）中实现一对一关系。其余的关联关系会在之后介绍。
JPA 中的一对一关系
allway2的博客
10-26 890
假设我们正在构建一个用户管理系统，我们的老板要求我们为每个用户存储一个邮寄地址。一个用户将有一个邮寄地址，一个邮寄地址将只有一个与之绑定的用户。现在，让我们想象一下，我们的员工与工作站相关联。在本文中，我们学习了在 JPA 和休眠中维护一对一关联的不同方法，以及何时使用每种方法。在本教程中，我们将了解在 JPA 中创建一对一映射的不同方法。表中主键的列的名称。是此关系的所有者，因为我们选择在其上使用联接表批注。最后，在下一个实体中请注意，我们不会在那里使用。现在，每当我们有关系时，我们将在。
springboot JPA Specification 一对多关联构造查询
Boreas_W的博客
04-19 1154
主表:Country import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.bean.copier.CopyOptions; import lombok.Data; import javax.persistence.*; import java.io.Serializable; @Data @Entity @Table(name = "country") public class Country implements Seria.
SpringData JPA-关联关系查询-创建一对多关联关系
失忆๑的博客
08-21 182
一）双项关联一对多 1.使用到的注解 @OneTomMany：在一对多的情况下，一方使用的注解 @Target({ElementType.METHOD, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) public @interface OneToMany { Class targetEntity() default void...
jpa一对多查询
人生最遗憾的莫过于：轻易地放弃了不该放弃的,固执地坚持了不该坚持的
05-21 307
Specification<Customer> spec = new Specification<Customer>() { @Override public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) { Pa...
JPA的复杂查询包括一对多多对一和多对多的查询
最新发布
m0_68856746的博客
01-07 3522
它们之间是多对多的关系，即一个学生可以选择多门课程，一门课程也可以有多个学生选择。我们想要查询选择了某门课程的所有学生，并且能够添加新的学生和课程。，它们之间是多对多的关系，即一个产品可以属于多个分类，一个分类也可以包含多个产品。现在，我们可以执行复杂查询，获取选择了某门课程的所有学生，并且能够添加新的学生和课程。方法执行了一个自定义查询，并只选择了客户的名称和邮箱属性。方法执行了一个复杂查询，获取选择了某门课程的所有学生。现在，我们可以执行多对多关联查询，并通过价格条件进行过滤。
如何使用JPA注解标注一对一的关系
weixin_33858485的博客
06-22 163
假设应用场景如下：Node与PageServer是一对一的关系，其中，Node类对应node表如下： CREATE TABLE `node` (  `id` bigint(20) NOT NULL AUTO_INCREMENT,  `name` varchar(50) DEFAULT NULL,  PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=3...
SpringData JPA：一对一与一对多关系详解及级联操作
在Spring Data JPA中，一对一关系可以通过`@OneToOne`注解在关联实体类中声明。这个注解允许你在关联的两个实体中任选其一来维护这一关系，这取决于需求。例如，在学校和地址类中，都使用了`@OneToOne(cascade=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值