JPA 一对多关联查询

已于 2022-03-21 10:38:32 修改
阅读量5.4k 收藏 14
点赞数 4
分类专栏： jpa spring boot orm 文章标签： spring boot jpa jpa关联查询 一对多关联查询 注解OneToMany 注解 JoinColumn
于 2022-03-18 09:51:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i402097836/article/details/123556007
版权
spring boot 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
jpa
1 篇文章 1 订阅
订阅专栏
orm
1 篇文章 0 订阅
订阅专栏

背景说明

本文以用户、订单、订单详情三者之间的关系来详细介绍jpa的功能使用。这个场景也比较符合实际开发中的业务场景。

  • 1查询订单的时候可以关联查询订单详情
  • 2查询用户信息的时候可以关联查询订单及订单详情

实际的业务中，用户和订单是一对多的关系，订单和订单详情也是一对多的关系。

数据库表

用户表（t_user）,订单表（t_order）,订单详情表（t_order_item）
三张表的结构如下：

  • t_user表
    在这里插入图片描述

  • t_order表在这里插入图片描述

  • t_order_item
    在这里插入图片描述
    注意：三张表不需手动创建，系统会自动创建。

码上开始

这里就不对jpa的一些基本知识展开讲了，不是很清楚的可以自己先学习下jpa基本的知识。
首先准备好基本的实体类。

1. 用户表相关实体类

package com.example.jpa.entity;

import java.io.Serializable;
import java.util.List;

public class User implements Serializable {
    
    private static final long serialVersionUID = 263434701950670170L;
    
    private long userId;
    
    private String username;
    
    private String pwd;

    public long getUserId() {
        return userId;
    }
    
    public void setUserId(final long userId) {
        this.userId = userId;
    }
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(final String username) {
        this.username = username;
    }
    
    public String getPwd() {
        return pwd;
    }
    
    public void setPwd(final String pwd) {
        this.pwd = pwd;
    }


    @Override
    public String toString() {
        return String.format("user_id: %d, username: %s, pwd: %s", userId, username, pwd);
    }
}


package com.example.jpa.entity;

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

import static javax.persistence.GenerationType.IDENTITY;

@Entity
@Table(name = "t_user")
public final class UserEntity extends User {
    private static final long serialVersionUID = -3708998745561667721L;
    @Id
    @Column(name = "user_id")
    @GeneratedValue(strategy = IDENTITY)
    @Override
    public long getUserId() {
        return super.getUserId();
    }
    
    @Column(name = "username")
    @Override
    public String getUsername() {
        return super.getUsername();
    }
    
    @Column(name = "pwd")
    @Override
    public String getPwd() {
        return super.getPwd();
    }
 }

2. 订单表实体类

public class Order implements Serializable {
    
    private static final long serialVersionUID = 661434701950670670L;
    
    private long orderId;
    
    private long userId;
    
    private long addressId;
    
    private String status;

    public long getOrderId() {
        return orderId;
    }
    
    public void setOrderId(final long orderId) {
        this.orderId = orderId;
    }
    
    public long getUserId() {
        return userId;
    }
    
    public void setUserId(final long userId) {
        this.userId = userId;
    }
    
    public String getStatus() {
        return status;
    }
    
    public void setStatus(final String status) {
        this.status = status;
    }
    
    public long getAddressId() {
        return addressId;
    }
    
    public void setAddressId(final long addressId) {
        this.addressId = addressId;
    }
    
    @Override
    public String toString() {
        return String.format("order_id: %s, user_id: %s, address_id: %s, status: %s", orderId, userId, addressId, status);
    }
}

package com.example.jpa.entity;

import java.io.Serializable;

public class OrderItem implements Serializable {
    
    private static final long serialVersionUID = 263434701950670170L;
    
    private long orderItemId;
    
    private long orderId;
    
    private long userId;
    
    private String status;


    public long getOrderItemId() {
        return orderItemId;
    }
    
    public void setOrderItemId(final long orderItemId) {
        this.orderItemId = orderItemId;
    }
    
    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(final long orderId) {
        this.orderId = orderId;
    }
    
    public long getUserId() {
        return userId;
    }
    
    public void setUserId(final long userId) {
        this.userId = userId;
    }
    
    public String getStatus() {
        return status;
    }
    
    public void setStatus(final String status) {
        this.status = status;
    }
    
    @Override
    public String toString() {
        return String.format("order_item_id:%s, order_id: %s, user_id: %s, status: %s", orderItemId, orderId,userId, status);
    }
}

3.订单详情实体类

package com.example.jpa.entity;

import java.io.Serializable;

public class OrderItem implements Serializable {
    
    private static final long serialVersionUID = 263434701950670170L;
    
    private long orderItemId;
    
    private long orderId;
    
    private long userId;
    
    private String status;


    public long getOrderItemId() {
        return orderItemId;
    }
    
    public void setOrderItemId(final long orderItemId) {
        this.orderItemId = orderItemId;
    }
    
    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(final long orderId) {
        this.orderId = orderId;
    }
    
    public long getUserId() {
        return userId;
    }
    
    public void setUserId(final long userId) {
        this.userId = userId;
    }
    
    public String getStatus() {
        return status;
    }
    
    public void setStatus(final String status) {
        this.status = status;
    }
    
    @Override
    public String toString() {
        return String.format("order_item_id:%s, order_id: %s, user_id: %s, status: %s", orderItemId, orderId,userId, status);
    }
}


package com.example.jpa.entity;

import javax.persistence.*;

@Entity
@Table(name = "t_order_item")
public final class OrderItemEntity extends OrderItem {

    private static final long serialVersionUID = 5685474394188443341L;

    @Id
    @Column(name = "order_item_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Override
    public long getOrderItemId() {
        return super.getOrderItemId();
    }

    @Column(name = "order_id")
    @Override
    public long getOrderId() {
        return super.getOrderId();
    }

    @Column(name = "user_id")
    @Override
    public long getUserId() {
        return super.getUserId();
    }

    @Column(name = "status")
    @Override
    public String getStatus() {
        return super.getStatus();
    }

}
  1. 插入测试数据

通过单元测试插入测试需要的数据。

 	@Test
    public void  insertData(){

        //插入用户数据
        UserEntity userEntity = new UserEntity();
        userEntity.setUsername("snail");
        userEntity.setPwd("123456");
        userRepository.save(userEntity);

        //插入订单数据
        OrderEntity order  = new OrderEntity();
        order.setAddressId(1);
        order.setOrderId(1);
        order.setUserId(userEntity.getUserId());
        order.setStatus("订单测试数据");
        orderRepository.save(order);

        //插入订单详情数据
        OrderItemEntity orderItemEntity = new OrderItemEntity();
        orderItemEntity.setOrderId(order.getOrderId());
        orderItemEntity.setUserId(userEntity.getUserId());
        orderItemEntity.setStatus("订单详情测试数据");
        orderItemRepository.save(orderItemEntity);
    }

查看下数据库的基础数据：

  • t_user表数据：
    在这里插入图片描述
  • t_order表中的数据：

在这里插入图片描述

  • t_order_item表中的数据：

在这里插入图片描述

  1. 开始实现第一个需求，查询订单时收关联查询订单详情。

    在order实体中加入以下代码：

 private List<OrderItem> orderItemList;

    public List<OrderItem> getOrderItemList() {
        return orderItemList;
    }

    public void setOrderItemList(List<OrderItem> orderItemList) {
        this.orderItemList = orderItemList;
    }

在OrderEntity中加入以下代码：

    @OneToMany(targetEntity = OrderItemEntity.class)
    @JoinColumn(name = "order_id")
    @Override
    public List<OrderItem> getOrderItemList() {
        return super.getOrderItemList();
    }

这里主要用到了两个注解@OneToMany表示一对多的关系

这里还是通过单元测试 查询订单表的数据，看看是否能自动查询订单详情的数据。

   @Test
    public void  selectOrder(){

        List<OrderEntity> all = orderRepository.findAll();
        System.out.println(new Gson().toJson(all));
    }

以下是执行结果：
在这里插入图片描述为了方便观看，把格式化好的数据一块贴出来：

[
    {
        "orderId":1,
        "userId":1,
        "addressId":1,
        "status":"订单测试数据",
        "orderItemList":[
            {
                "orderItemId":1,
                "orderId":1,
                "userId":1,
                "status":"订单详情测试数据"
            }
        ]
    }
]

这里主要是其实主要就用到了两个注解：

@OneToMany(targetEntity = OrderItemEntity.class)
@JoinColumn(name = "order_id")
  1. 同样的操作我们就可以实现查询用户的时候关联查询订单信息。

修改User实体类，添加以下代码：

 private List<Order> orderList;
    public List<Order> getOrderList() {
        return orderList;
    }
    public void setOrderList(List<Order> orderList) {
        this.orderList = orderList;
    }

修改UserEntity类，添加以下代码：

  	@OneToMany(targetEntity = OrderEntity.class)
    @JoinColumn(name = "user_id")
    @Override
    public List<Order> getOrderList() {
        return super.getOrderList();
    }

还是采用单元测试来测试我们的代码：

 @Test
    public void  selectUser(){

        List<UserEntity> all = userRepository.findAll();
        System.out.println(new Gson().toJson(all));
    }

执行结果：
在这里插入图片描述格式化下代码结果：

[
    {
        "userId":1,
        "username":"snail",
        "pwd":"123456",
        "orderList":[
            {
                "orderId":1,
                "userId":1,
                "addressId":1,
                "status":"订单测试数据",
                "orderItemList":[
                    {
                        "orderItemId":1,
                        "orderId":1,
                        "userId":1,
                        "status":"订单详情测试数据"
                    }
                ]
            }
        ]
    }
]

这样就实现了本来开始说的两个需求了。如果问题请留言讨论。

以上这种一对多的关联方式其实是一种单向的一对多关联，通过外键的方式。可以查看数据表会生产对应的外键信息。

骑着蜗牛百米冲刺
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JPA中的一对多
qq_42836176的博客
12-04 3284
2.1 表之间关系的划分 数据库中多表之间存在着三种关系，如图所示。 从图可以看出，系统设计的三种实体关系分别为：多对多、一对多和一对一关系。注意：一对多关系可以看为两种： 即一对多，多对一。所以说四种更精确。 明确： 我们今天只涉及实际开发中常用的关联关系，一对多和多对多。而一对一的情况，在实际开发中几乎不用。 2.2 在JPA框架中表关系的分析步骤 在实际开发中，我们数据库的表难免会有相互...
JPA之JPA中的一对多双向关联
BruceLeeNumberOne的博客
11-19 1054
如果要搭建JPA开发环境，请从JPA第一篇博客看起。 JPA规范规定，在双向的一对多或者多对一关系中，多的一方为关系维护端，关系维护端负责外键记录的更新，关系被维护端是没有权利更新外记录。   这里以订单和订单项为例，一个订单可以有多个订单项，一个订单项只归属于某个订单。 1、新建Order类，编写代码如下 package cn.sunft.bean; import
Spring Boot JPA级联查询【一对多、多对一】
u014713873的博客
05-24 8275
一、数据准备 在管理系统中，角色和用户是典型一对多关系，一个角色可以分配给多个用户，一个用户对应一个角色。准备两个实体类TestRole、TestUser类，并在数据库建好对应表结构z_test_roles、z_test_users两张表。 @Entity @Getter @Setter @Table(name = "z_test_roles") public class TestRole implements Serializable { @Id @Column(na...
java jpa 关联查询，left join、子查询
u013263373的博客
02-01 1393
java jpa 关联查询，left join、子查询
【跟着例子学MySQL】多表关联 -- 一对多关系
最新发布
用最通俗的方式，分享最硬核的知识
05-20 1562
上篇文章👉《【跟着例子学MySQL】数据更新 -- 更新,删除和导入导出》]讲了如何更新和导出数据。这篇开始讲解多表关联的相关内容。
SpringBoot JPA 表关联查询实例
08-30
本篇文章主要介绍了SpringBoot JPA 表关联查询实例，使用JPA原生的findBy语句实现，具有一定的参考价值，有兴趣的可以了解一下。
JPA一对多、多对多理解和配置小记
梅子黄时雨
02-01 643
JPA一对多、多对多理解和配置小记
【Java】SpringData JPA快速上手，关联查询，JPQL语句书写
m0_73976305的博客
09-15 1844
JPA框架 认识SpringData JPA 使用JPA快速上手 方法名称拼接自定义SQL 关联查询 JPQL自定义SQL语句
jpa 多表关联查询
srj904711648的博客
03-02 2369
jpa 多表关联查询
java使用JPA进行数据查询和join关联查询
djj1015591892的博客
11-29 2073
jpa的OneToOne，内连接，CriteriaQuery等的使用
Spring Data JPA 实现多表关联查询的示例代码
08-27
在Spring Data JPA中，多表关联查询是一个常见的需求，特别是在复杂的业务场景下。本文将主要探讨通过创建结果集接口的方式来实现多表关联查询的方法，而不是依赖Hibernate的级联查询。 首先，我们要了解Spring ...
Hibernate一对多关联双向关联代码实现分享
09-04
在关系型数据库中，一对多关联是指一个表的记录可以对应另一个表的多个记录。在Hibernate中，这种关系可以通过在实体类和映射文件中设置相应的属性来实现。具体到双向关联，意味着在两个关联的实体类中，每个实体都...
JPA中的一对多双向关联与级联操作
05-14
一对多关联是数据库设计中的常见关系类型，一个实体可以拥有多个相关联的实体实例。在JPA中，这种关系可以通过在实体类中定义`@OneToMany`注解来实现。这个注解告诉JPA一个实体（例如，一个用户）可以有多个相关的...
JPA的多表复杂查询的方法示例
08-25
在实际开发中，经常需要对多个表进行关联查询，例如根据用户信息查询订单信息，然后根据订单信息查询商品信息。使用JPA的多表关联查询机制可以轻松实现该功能。 ```java public class Living { Long id; @...
JPA的一对一、一对多、多对多查询
qq_43975645的博客
07-20 434
因为Blog类中的userId和User类中的id都指向同一个数据库字段，这样就会导致级联更新时重复修改而报错。一对多要相互依赖，首先有多对一，这里Blog类中需要定义一个User，并添加注解。都会将关联的实体类对象包含进去，导致执行查询时循环调用到栈溢出。然后User类中需要定义Blog集合，接收多个Blog对象。区别只是类型是单个对象还是集合对象。在JPA中要慎用，因为重写的。，指定name关联的字段。
Spring JPA 联表查询 ： OneToMany
Java技术攻略的博客
04-28 1675
我们在实际项目中，除了会碰到一对一的情况，还有一对多的情况，比如一个用户可以有多辆车，而一辆车只能有一个用户等等，今天我们就来一起学习下 OneToMany（一对多）。
SpringBoot中使用JPA进行一对多查询
Lans2716的博客
06-08 2654
一、JPA介绍 Jpa (Java Persistence API) 是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在 Hibernate，TopLink，JDO 等 ORM 框架各自为营的局面。 值得注意的是，Jpa是在充分吸收了现有 Hibernate，TopLink，JDO 等 ORM 框架的基础上发展而来的，具有易于使用，伸缩性强等优点。从目前
jpa使用自定义sql 一对多 @Query
weixin_49723367的博客
08-18 510
这是我最近写测试的时候用到的方法，因这种方法，不是特别可取。数据量很多的时候，此批量查询时是最快的。这时查询出来的值就是多条，用代码分组后组装数据，返回数据。table1 与table 2 是一对多的关系。
JPA的复杂查询包括一对多多对一和多对多的查询
m0_68856746的博客
01-07 3263
它们之间是多对多的关系，即一个学生可以选择多门课程，一门课程也可以有多个学生选择。我们想要查询选择了某门课程的所有学生，并且能够添加新的学生和课程。，它们之间是多对多的关系，即一个产品可以属于多个分类，一个分类也可以包含多个产品。现在，我们可以执行复杂查询，获取选择了某门课程的所有学生，并且能够添加新的学生和课程。方法执行了一个自定义查询，并只选择了客户的名称和邮箱属性。方法执行了一个复杂查询，获取选择了某门课程的所有学生。现在，我们可以执行多对多关联查询，并通过价格条件进行过滤。
jpa一对多关联查询
09-21
JPA（Java Persistence API）是Java EE的一种规范，用于管理Java应用程序中的对象关系映射。在JPA中，一对多关联查询可以通过@OneToMany注解来实现。 在JPA中，一对多关联查询可以通过设置fetch属性为FetchType.EAGER来实现立即加载，或者使用懒加载方式，需要在业务代码上添加@Transcational注解。 下面是一个示例代码，演示了如何进行一对多关联查询： ```java // 单向一对多查询 @Entity public class TestRole { @OneToMany(mappedBy = "testRole", fetch = FetchType.EAGER) private List<TestUser> testUsers; // other properties and methods } @Entity public class TestUser { // properties and methods } // 双向一对多查询 @Entity public class TestRole { @OneToMany(mappedBy = "testRole", fetch = FetchType.LAZY) private List<TestUser> testUsers; // other properties and methods } @Entity public class TestUser { @ManyToOne @JoinColumn(name = "role_id") private TestRole testRole; // other properties and methods } ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值