SpringBoot中使用jpa实现一对多(或者多对一)的处理(纯注解的实现方式)

最新推荐文章于 2024-04-26 08:00:00 发布
最新推荐文章于 2024-04-26 08:00:00 发布
阅读量6k 收藏 21
点赞数 3
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45492007/article/details/102855394
版权

当前环境：idea、springboot

1.简介

由于要求需要使用springboot中使用jpa来简化开发，但是对于一对多或者多对一的关系还是不够了解(由于是使用注解版的)。

所以这里使用了：一个学生对应一个班级，但是一个班级中具有多个学生，所以可以理解为：一个班级中具有一个许多学生(一个班级中具有一个学生集合)，一个学生属于一个班级

2.编写数据库

classes班级表中表结构：
在这里插入图片描述
学生表users中的表结构：
在这里插入图片描述
添加字段：
在这里插入图片描述
在这里插入图片描述

3.开始创建idea基本的项目

由于本人使用idea中的eclipse中的快捷键感觉不爽，所以就改了快捷键
在这里插入图片描述

3.1 创建一个maven项目

1.创建一个空的maven项目，然后添加如下文件夹
在这里插入图片描述

将需要的文件夹标记为java源文件和资源文件，其中出现了一个不能创建class文件的东西(通过查看设置发现所有的模板都是空的)，解决办法如下：

1.找到idea中vmoptions，看你的计算机位数，选择，（本人64位，所以编辑idea64.exe.vmoptions文件）
在这里插入图片描述

在最后面添加如下内容：
在这里插入图片描述
重启后就有了：
在这里插入图片描述

3.2.现在开始编写pom文件

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hy</groupId>
    <artifactId>hy</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>EnterpriseTalentManagement</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

3.3 创建和编写application.yml文件

spring:
  datasource:
    url: jdbc:mysql:///test?useEncoding=utf8
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root

  jpa:
      show-sql: true

3.4 创建基本的类和基本的包

在这里插入图片描述

3.5 编写实体类

User中的内容

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

/**
 * Created by admin on 2019/11/1.
 * 用于描述当前班级中的学生,一个学生只能在一个班级，但是一个班级具有多个学生
 */
@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "username", nullable = false)
    private String username;

    @Column(name = "password", nullable = false)
    private String password;

    @Column(name = "classes_id",nullable = false)
    private Integer classesId;

    //由于这里重写了toString所以会产生一个死循环的后果，所以只能配置单项的一对多或者单项的多对一
   /* @ManyToOne(targetEntity = Classes.class, fetch = FetchType.LAZY)
    private Classes classes;*/
}

Classes类总的内容

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.Columns;

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

/**
 * Created by admin on 2019/11/1.
 * 班级，一个班级具有多个学生，但是一个学生只能在一个班级中读书
 */
@Entity
@Table(name="classes")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Classes {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "classname",nullable = false)
    private String className;

     @OneToMany(targetEntity = User.class,mappedBy ="classesId")
    private List<User> users;
}

@OneToMany就是代表一个Classes中对应的多个的类为User，通过实体类User中的classesId进行关联(默认数据库采用classes_id方式)，这里有一个bug(如果mappedBy这里写成其他的就报错)

@ManyToOne就表示多个User对应一个班级，通过Classes类进行关联,建议使用ManyToOne这个比较简单，另外一个需要指定mappedBy可能出现错误！

3.6 编写Dao层

UserDao中的内容

import com.hy.springboot.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created by admin on 2019/11/1.
 */
@Repository
public interface UserDao extends JpaRepository<User,Integer>{
}

ClassesDao中的内容

import com.hy.springboot.demo.entity.Classes;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created by admin on 2019/11/1.
 */
@Repository
public interface ClassesDao extends JpaRepository<Classes,Integer> {
}

由于当前的jpa中提供了简化对数据库操作的模板：JpaRepository,需要添加@Repository注解，查看结构树：f4
在这里插入图片描述
所以这里可以按照自己的方式继承该接口类！

3.7 编写controller层

import com.hy.springboot.demo.dao.ClassesDao;
import com.hy.springboot.demo.dao.UserDao;
import com.hy.springboot.demo.entity.Classes;
import com.hy.springboot.demo.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * Created by admin on 2019/11/1.
 */
@RestController
public class MainController {
    @Autowired
    UserDao userDao;

    @Autowired
    ClassesDao classesDao;

    @RequestMapping("/hi")
    public String main(String hi) {
        return "welcome to SpringBoot Application!";
    }

    /**
     * 这里用于获取用户的信息，如果这里配置了多对一，表示会被关联
     * @return
     */
    @RequestMapping("/userList")
    public String findUserAll() {
        List<User> userList = userDao.findAll();
        boolean empty = CollectionUtils.isEmpty(userList);
        return empty ? "没有数据" : userList.toString();
    }

    /**
     * 用于查询所有的班级信息，如果班级这里配置了一对多就表示会被关联
     * @return
     */
    @RequestMapping("/classesList")
    public String findClassesAll() {
        List<Classes> classesList = classesDao.findAll();
        boolean empty = CollectionUtils.isEmpty(classesList);
        return empty ? "没有数据" : classesList.toString();
    }

3.8 编写入口类

@SpringBootApplication
@EnableJpaRepositories(basePackages = "com.hy.springboot.demo.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

4.测试

在这里插入图片描述

在这里插入图片描述
测试成功！

5.总结

1.对于使用注解的方式完成多对一和一对多，建议使用@ManyToOne实现，只需要指定多个当前类对应的一个类的这一个类的类型即可完成

2.在使用jpa的时候需要注意当前的实体类字段类型，如果使用驼峰命名法，就会产生对应的数据库列：名称_名称的方式的列，注意这里

3.在使用@OneToMany的时候需要指定当前的这一个类型对应的多个类型的类(多个的类)，并指定被哪个MappedBy(外键所使用)

4.再次会议起当前的单项一对多和多项多对一就会再次明白一些，学习就是一个不断复习和学习的过程！

以上纯属个人见解，如有问题请联系本人！

编程写手
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot—多对一或一对多关系的多种实现方法
白白白鲤鱼的博客
05-15 992
SpringBoot—多对一或一对多关系的多种实现方法
Spring Boot JPA级联查询【一对多、多对一】
u014713873的博客
05-24 8251
一、数据准备 在管理系统中，角色和用户是典型一对多关系，一个角色可以分配给多个用户，一个用户对应一个角色。准备两个实体类TestRole、TestUser类，并在数据库建好对应表结构z_test_roles、z_test_users两张表。 @Entity @Getter @Setter @Table(name = "z_test_roles") public class TestRole implements Serializable { @Id @Column(na...
SpringData——JPA映射单向一对多和多对一
最新发布
程序员阿皓的博客
04-26 252
JPA中的单向一对多和多对一是常见的关联关系，用于描述实体之间的关联。在单向一对多关系中，；在多对一关系中，。
Jpa的多对一
Strive_Peter的博客
07-27 875
防守打法的
spring boot Jpa 一对多关系维护 @OneToMany
u013185759的博客
12-11 6966
     业务中经常会出现对象有一对多的关系，如 小明有多张银行等。      表结构如下:      注意这里我没有指定外键关系。      如果要持久化这些对象，按照以往的做法先生成小明，赋予ID，再将这个ID设置为在银行卡的外键。      但是JPA指定了更为方便的做法。      从生成实体类开始(我使用的是IDEA) 1.添加数据源       2.生成实体类 ...
Spring Data JPA一对多关联保存到数据库外键为空
Apple South的博客
03-21 9162
今天碰到一个问题，在使用Spring Data JPA一对多关联时候保存到数据库，数据都保存了，但是外键的值为空！ 原因：实体类配置关联关系后还要在保存的时候体现出关联性。 PS:如果有看不懂的可以给我留言，这个问题我搞了半天，哎 多的一方： @ManyToOne @JoinColumn(name = "notify_id") private Notify notify; 一的一...
7、JPA对象关系-双向多对一(mappedBy比较少用)
红鹰
07-08 488
JPA对象关系-双向多对一双向多对一(很少用)废话不多数，看下面代码1、实体类定义2、persistence.xml 配置3、单元测试类4、控制台输出5、JPA维护了2个关系6、用`mappedBy`解决双向多对一出现2个关系问题JPA 双向时，也不会级联保存双向多对一，如何手动维护关系？@JoinColumn 双向多对一(很少用) 双向多对一就是 通过A对象可以找到B对象，同理通过B对象可以找到A对象，他们之间互相依赖。 既然他们互相依赖，在JSON序列化或ToString时就会报出栈内存溢出，并且业务
使用springboot + JPA / MyBatis 实现多数据源动态切换
04-17
4. **动态数据源切换**：对于MyBatis，可以在SqlSessionTemplate中设置数据源，或者使用`@MapperScan`注解配合自定义数据源路由类来实现。 **六、实战项目分析** 在`springboot-multi-datasource-master`项目中，...
Springboot中使用JPA操作数据库
04-22
以下是对如何在Spring Boot中使用Spring Data JPA进行数据库操作的详细解析。 首先，**JPA** 是Java EE规范的一部分，它提供了一种标准的方式来映射对象到关系型数据库，通过Entity Beans来实现ORM（对象关系映射）...
springboot+jpa配置多数据源.zip
12-06
下面我们将深入探讨如何在Spring Boot项目中使用这些技术实现这一目标。 首先，`springboot+jpa配置多数据源.zip`这个压缩包可能包含了一个示例项目，用于演示如何在Spring Boot中集成JPA并配置多个数据源。JPA是...
springboot同时整合JPA和mybatis的demo
08-12
本示例"springboot同时整合JPA和mybatis的demo"旨在演示如何在一个项目中同时使用Spring Boot与两种ORM（对象关系映射）框架：JPA（Java Persistence API）和MyBatis。这为我们提供了更大的灵活性，可以根据不同的...
JPA例子(里面有一对一，一对多的例子)
08-06
JPA的几个例子，一对一，一对多。 @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY) @JoinColumn(name = "personid", unique = false, nullable = true, insertable = true, updatable = true) public Person getPerson() { return this.person; } public void setPerson(Person person) { this.person = person; }
Spring boot整合Mybatis实现级联一对多CRUD操作的完整步骤
08-25
主要给大家介绍了关于Spring boot整合Mybatis实现级联一对多CRUD操作的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
SpringBoot+JPA
04-03
而JPA（Java Persistence API）是Java平台上的ORM（Object-Relational Mapping）标准，它允许开发者用面向对象的方式处理数据库操作。将SpringBoot与JPA结合，可以实现高效、简洁的数据库访问。本文将详细介绍如何在...
Spring Data JAP框架处理表关系的步骤（一对多
狗凡的博客
10-11 438
Spring Data JAP框架处理表关系的步骤： 1）确定表和表之间的关系 2）对应表创建实体类 3）在实体类配置注解关联关系 4）测试 一对多表关系的实现方案： 1 在Customer实体类中添加属性LinkMan类型，在LinkMan实体类中添加属性Customer类型 2 在1的一方新添的属性上添加注释@OneToMany，代表是一对多 3在多的...
SpringDataJpa一对多、多对一关系关联以及一对多多对一双向关联
Mr_chen的博客
11-19 1020
SpringDataJpa一对多、多对一关系关联以及一对多多对一双向关联 前言 案例Github地址(可以用git clone 到本地) https://github.com/chenxiban/SpringBootJpa-One-To-Many.git 今天为大家分享：SpringDataJpa一对多、多对一关系关联以及一对多多对一双向关联。 前面讲了SpringDataJpa自定义查询语句(...
Spring Data JPA 高级（实现一对多、多对一、多对多）关联
chaotiantian的博客
04-23 2733
单向一对多关联关系 以学生表和班级表为例 //班级实体类 @Data @Entity @Table(name = "class") public class Clazz { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; private String cname; // 一对多 // 存放所有学生 // 懒加载fetch 级联加载cascade @OneToMany(fetch = Fetch
002_Spring Data JPA CRUD
aihiao的专栏
02-17 422
1. 创建一个名为spring-data-jpa-crud的Java项目, 同时添加相关jar包, 并添加JUnit能力。 2. 查看CrudRepository接口下的方法, 我们使用红色框中的方法。 3. 新建User.java package com.bjbs.pojo; import java.io.Serializable; import java.util.Date; import javax.persistence.Column; import javax.persisten
JAP中的单向一对多,单向多对一
qq_43257103的博客
05-27 699
package zhang.jpa.helloword; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.persistence.CascadeType; import javax.persistence.EntityManage...
帮我写一个springboot +jpa 一对多的添加
03-07
好的，我可以为您提供一个springboot jpa一对多的添加示例。假设我们有两个实体类，一个是Order（订单），另一个是OrderItem（订单项），一个订单可以有多个订单项。 首先，我们需要在Order实体类中添加一个OneToMany注解，表示一个订单可以有多个订单项： ``` @Entity public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true) private List<OrderItem> orderItems = new ArrayList<>(); //其他属性和方法省略 } ``` 然后，在OrderItem实体类中添加ManyToOne注解，表示一个订单项属于一个订单： ``` @Entity public class OrderItem { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "order_id") private Order order; //其他属性和方法省略 } ``` 接下来，我们可以在OrderController中添加一个添加订单项的接口： ``` @RestController @RequestMapping("/orders") public class OrderController { @Autowired private OrderRepository orderRepository; @PostMapping("/{orderId}/orderItems") public Order addOrderItem(@PathVariable Long orderId, @RequestBody OrderItem orderItem) { Order order = orderRepository.findById(orderId).orElseThrow(() -> new RuntimeException("Order not found")); orderItem.setOrder(order); order.getOrderItems().add(orderItem); return orderRepository.save(order); } } ``` 在这个接口中，我们首先通过orderId查询到对应的订单，然后将订单项的order属性设置为该订单，最后将订单项添加到订单的orderItems列表中，并保存订单。 这就是一个简单的springboot jpa一对多的添加示例。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值