SpringDataJpa的使用 -- 一对一、一对多、多对多 关系映射

于 2022-07-06 22:32:17 发布
阅读量1.1k 收藏 6
点赞数 2
分类专栏： 数据库 学习笔记 文章标签： 数据库 mysql java spring boot hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46766584/article/details/125649012
版权

SpringDataJpa的使用 – 一对一、一对多、多对多 关系映射

本文主要讲述 @OneToOne、@OneToMany、@ManyToOne、@ManyToMany 这四个关系映射注解的使用，以及其对应的级联关系

有四张表，分别是：学生表、家长表、教室表、教师表，它们的关联关系如下：

  • 学生 对 家长：一对一
  • 学生 对 教室：多对一
  • 学生 对 教师：多对多

项目依赖

必要的依赖有：mysql驱动、SpringBootWeb、SpringBootStarter、SpringDataJpa、SpringBootText、druid，其它的依赖可以按需添加。
如：lombok、

pom.xml 必要依赖

<!-- Spring Boot 都使用 2.4.5，看个人习惯 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.4.5</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.4.5</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test</artifactId>
<version>2.4.5</version>
<scope>runtime</scope>
</dependency>
        <!-- Spring Data JPA 使用 2.6.1，看个人习惯 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>2.6.1</version>
</dependency>

        <!-- mysql 驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.25</version>
<scope>runtime</scope>
</dependency>
        <!-- druid 数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.24</version>
</dependency>

pom.xml 可选依赖

<!--  Spring 热部署  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <version>2.4.5</version>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>
        <!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
<optional>true</optional>
</dependency>

项目配置

application.yaml

spring:
  # DataSource
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: 账号
    password: 密码
    # serverTimezone可以设置为北京时间GMT%2B8、上海时间Asia/Shanghai或者香港时间Hongkong
    url: jdbc:mysql://localhost:3306/cloudtext?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
  # DataBase Connection -- JPA
  jpa:
    # 显示 SQL 语句
    show-sql: true
    # 不允许在视图阶段 执行 sql
    open-in-view: false

# 建议设置一个不常用的，避免冲突
server:
  # 项目端口号
  port: 8092
  # 项目路径
  servlet:
    context-path: /jpa

sql文件（MySQL版）

cloudText.sql 仅结构

-- ----------------------------
-- Table structure for classroom
-- ----------------------------
DROP TABLE IF EXISTS `classroom`;
CREATE TABLE `classroom` (
 `class_room_id` tinyint unsigned NOT NULL AUTO_INCREMENT COMMENT '班级主键',
 `class_room_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin DEFAULT NULL COMMENT '班级名称',
 `class_room_location` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin DEFAULT NULL COMMENT '班级位置',
  `class_room_capacity` int unsigned DEFAULT NULL COMMENT '班级人数',
  `class_room_grade` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin DEFAULT NULL COMMENT '班级年级',
 PRIMARY KEY (`class_room_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

-- ----------------------------
-- Table structure for patriarch
-- ----------------------------
DROP TABLE IF EXISTS `patriarch`;
CREATE TABLE `patriarch` (
 `patriarch_id` tinyint unsigned NOT NULL AUTO_INCREMENT COMMENT '家长主键',
 `patriarch_name` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '家长姓名',
 `patriarch_age` int unsigned DEFAULT NULL COMMENT '家长年龄',
 `patriarch_sex` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '家长性别',
 `patriarch_phone` varchar(11) COLLATE utf8_bin DEFAULT NULL COMMENT '家长电话',
 `patriarch_address` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '家长住址',
 PRIMARY KEY (`patriarch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
 `student_id` tinyint unsigned NOT NULL AUTO_INCREMENT COMMENT '学生主键',
 `student_name` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '学生姓名',
 `student_age` int unsigned DEFAULT NULL COMMENT '学生年龄',
 `student_sex` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '学生性别',
 `patriarch_id` tinyint unsigned NOT NULL COMMENT '家长外键',
 `class_room_id` tinyint unsigned DEFAULT NULL COMMENT '班级外键',
 PRIMARY KEY (`student_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

-- ----------------------------
-- Table structure for student_teacher
-- ----------------------------
DROP TABLE IF EXISTS `student_teacher`;
CREATE TABLE `student_teacher` (
 `student_id` tinyint unsigned NOT NULL COMMENT '学生主键',
 `teacher_id` tinyint unsigned NOT NULL COMMENT '教师主键',
 PRIMARY KEY (`student_id`,`teacher_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;


-- ----------------------------
-- Table structure for teacher
-- ----------------------------
DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher` (
 `teacher_id` tinyint unsigned NOT NULL AUTO_INCREMENT COMMENT '教师主键',
 `teacher_name` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '教师姓名',
 `teacher_age` int unsigned DEFAULT NULL COMMENT '教师年龄',
 `teacher_sex` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '教师性别',
 `teacher_course` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '教师教授科目',
 PRIMARY KEY (`teacher_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

级联关系简述

  • ALL – 级联所有操作
  • PERSIST – 级联持久化操作
  • MERGE – 级联合并操作
  • REMOVE – 级联删除操作
  • REFRESH – 级联刷新操作（调用refresh方法才会刷新）
  • DETACH – 级联分离操作（2.0版本才有）

参考：《Spring Boot 整合——JPA 数据模型关联操作（一对一、一对多、多对多）》
参考：《cascade级联关系》

@OneToOne 一对一 关系映射

一对一关系的双方必须有且仅有一方放弃维护，在 @OneToOne 中添加mappedBy属性表示放弃维护。

学生类（Student.java）：维护方
家长类（Patriarch.java）：被维护方

Student.java (主键和非外键属性)

package com.ljm.exmaple.entity;

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * 学生 类
 *
 * @author LJM
 */
@Entity
@Table(name = "STUDENT")
public class Student {
	
	/**
	 * 学生 id
	 */
	@Id
	@Column(name = "student_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long studentId;
	/**
	 * 学生 姓名
	 */
	@Column(name = "student_name", nullable = false)
	private String studentName;
	/**
	 * 学生 年龄
	 */
	@Column(name = "student_age", nullable = false)
	private Short studentAge;
	/**
	 * 学生 性别
	 */
	@Column(name = "student_sex", nullable = false)
	private String studentSex;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}

Patriarch.java (主键和非外键属性)

package com.ljm.exmaple.entity;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * 家长 类
 *
 * @author LJM
 */
@Entity
@Table(name = "PATRIARCH")
public class Patriarch {
	/**
	 * 家长 id
	 */
	@Id
	@Column(name = "patriarch_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long patriarchId;
	/**
	 * 家长 姓名
	 */
	@Column(name = "patriarch_name", nullable = false)
	private String patriarchName;
	/**
	 * 家长 年龄
	 */
	@Column(name = "patriarch_age")
	private Short patriarchAge;
	/**
	 * 家长 性别
	 */
	@Column(name = "patriarch_sex", nullable = false)
	private String patriarchSex;
	/**
	 * 家长 电话
	 */
	@Column(name = "patriarch_phone", nullable = false, length = 11)
	private String patriarchPhone;
	/**
	 * 家长 住址
	 */
	@Column(name = "patriarch_address", nullable = false)
	private String patriarchAddress;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}
1.无中间表，维护方添加外键，被维护方添加对应项

cascade = CascadeType.ALL 表示：级联关系。
fetch = FetchType.EAGER 表示：预加载。
name = “patriarch_id” 指定外键。
nullable = false 表示：不能为空。
unique = true 表示：不能重复。
mappedBy = “patriarch” ：添加了这个属性表示放弃维护。

维护方的属性添加到 Student.java 中。
被维护方的属性添加到 Patriarch.java 中。

/**
 * 一对一
 * 家长 外键
 * 维护方   
 * 使用  CascadeType.ALL 亦可，区别不大
 */
@OneToOne(cascade = {CascadeType.MERGE, CascadeType.REMOVE}, fetch = FetchType.EAGER)
@JoinColumn(name = "patriarch_id", nullable = false, unique = true)
private Patriarch patriarch;


/**
 * 一对一
 * 被维护方（对应项）
 * 使用  CascadeType.ALL 亦可，区别不大
 */
@OneToOne(mappedBy = "patriarch", cascade = {CascadeType.REFRESH, CascadeType.MERGE, CascadeType.REMOVE}, fetch = FetchType.EAGER)
private Student student;

/** 注意，外键及对应项的 Getter、Setter 不要忘了 */
2.无中间表，维护方添加外键，被维护方不添加对应项

cascade = CascadeType.ALL 表示：级联关系。
fetch = FetchType.EAGER 表示：预加载。
name = “patriarch_id” 指定外键。
nullable = false 表示：不能为空。
unique = true 表示：不能重复。

维护方的属性添加到 Student.java 中。

/**
 * 一对一
 * 家长 外键
 * 维护方   
 * 使用  CascadeType.ALL 亦可，区别不大
 */
@OneToOne(cascade = {CascadeType.MERGE, CascadeType.REMOVE}, fetch = FetchType.EAGER)
@JoinColumn(name = "patriarch_id", nullable = false, unique = true)
private Patriarch patriarch;


/**
 * 一对一
 * 被维护方（对应项）,不需要添加对应项
 * 使用  CascadeType.ALL 亦可，区别不大
 */
/**
 * @OneToOne(mappedBy = "patriarch", cascade = {CascadeType.REFRESH, CascadeType.MERGE, CascadeType.REMOVE}, fetch = FetchType.EAGER)
 * private Student student;
 */

/** 注意，外键的 Getter、Setter 不要忘了 */
3.有中间表，维护方不添加外键，被维护方不添加对应项

暂缺，这不是本文重点，以后可能会添加。
不需要使用关系注解 @OneToOne、@OneToMany、@ManyToOne、@ManyToMany，没有外键。

@OneToMany、@ManyToOne 一对多 关系映射

一对多关系中，多方必须维护外键，一方一般不维护（我在某篇文章中看到：说一方也可以维护外键，我还未验证）。

学生类（Student.java）：维护方
教室类（ClassRoom.java）：被维护方

Student.java (主键和非外键属性)

package com.ljm.exmaple.entity;

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * 学生 类
 *
 * @author LJM
 */
@Entity
@Table(name = "STUDENT")
public class Student {
	
	/**
	 * 学生 id
	 */
	@Id
	@Column(name = "student_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long studentId;
	/**
	 * 学生 姓名
	 */
	@Column(name = "student_name", nullable = false)
	private String studentName;
	/**
	 * 学生 年龄
	 */
	@Column(name = "student_age", nullable = false)
	private Short studentAge;
	/**
	 * 学生 性别
	 */
	@Column(name = "student_sex", nullable = false)
	private String studentSex;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}

ClassRoom.java (主键和非外键属性)

package com.ljm.exmaple.entity;

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * 教室 类
 *
 * @author LJM
 */
@Entity
@Table(name = "CLASSROOM")
public class ClassRoom {
	/**
	 * 教室 id
	 */
	@Id
	@Column(name = "classRoom_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long classRoomId;
	/**
	 * 教室 名称
	 */
	@Column(name = "classRoom_name", nullable = false)
	private String classRoomName;
	/**
	 * 教室 位置
	 */
	@Column(name = "classRoom_location", nullable = false)
	private String classRoomLocation;
	/**
	 * 教室 容量
	 */
	@Column(name = "classRoom_capacity", nullable = false)
	private Short classRoomCapacity;
	/**
	 * 教室 所在的 班级的年级（小学到高中）
	 */
	@Column(name = "classRoom_grade", nullable = false)
	private String classRoomGrade;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}
1.无中间表，多方维护并添加外键，一方被维护

cascade = CascadeType.XXX 表示：级联关系。
fetch = FetchType.EAGER 表示：预加载。
name = “classRoom_id” 指定外键。
nullable = false 表示：不能为空。
mappedBy = “classRoom” ：添加了这个属性表示放弃维护，在一对多的一方用来指向多方的那个外键属性。

/**
 * 多对一
 * 多方
 * 教室外键
 * 维护方，级联关系为 none（没有，默认）
 */
@JoinColumn(name = "classRoom_id", nullable = false)
@ManyToOne(fetch = FetchType.EAGER)
private ClassRoom classRoom;


/**
 * 一对多
 * 一方
 * （被）维护方（对应项）
 * 被维护方代码
 */
@OneToMany(mappedBy = "classRoom", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, fetch = FetchType.EAGER)
private List<Student> studentList;

/** 注意，外键及对应项的 Getter、Setter 不要忘了 */
2.有中间表，多方维护，一方被维护

暂缺，这不是本文重点，以后可能会添加。
不需要使用关系注解 @OneToOne、@OneToMany、@ManyToOne、@ManyToMany，没有外键。

3.无中间表，多方维护，一方也维护

暂缺，待验证。

@ManyToMany 多对多 关系映射

多对多关系中，必须有且仅有一方放弃维护外键，需要新建中间表，但不需要写对应的实体类。

学生类（Student.java）：维护方
教师类（Teacher.java）：被维护方

Student.java (主键和非外键属性)

package com.ljm.exmaple.entity;

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * 学生 类
 *
 * @author LJM
 */
@Entity
@Table(name = "STUDENT")
public class Student {
	
	/**
	 * 学生 id
	 */
	@Id
	@Column(name = "student_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long studentId;
	/**
	 * 学生 姓名
	 */
	@Column(name = "student_name", nullable = false)
	private String studentName;
	/**
	 * 学生 年龄
	 */
	@Column(name = "student_age", nullable = false)
	private Short studentAge;
	/**
	 * 学生 性别
	 */
	@Column(name = "student_sex", nullable = false)
	private String studentSex;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}

Teacher.java (主键和非外键属性)

package com.ljm.exmaple.entity;


import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

/**
 * 教师 类
 *
 * @author LJM
 */
@Entity
@Table(name = "TEACHER")
public class Teacher {
	/**
	 * 教师 id
	 */
	@Id
	@Column(name = "teacher_id", nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long teacherId;
	/**
	 * 教师 姓名
	 */
	@Column(name = "teacher_name", nullable = false)
	private String teacherName;
	/**
	 * 教师 年龄
	 */
	@Column(name = "teacher_age")
	private Integer teacherAge;
	/**
	 * 教师 性别
	 */
	@Column(name = "teacher_sex", nullable = false)
	private String teacherSex;
	/**
	 * 教师 所教的 科目
	 */
	@Column(name = "teacher_course", nullable = false)
	private String teacherCourse;
	/** 省略 Constructor、Getter、Setter、toString 方法 **/
}

fetch = FetchType.EAGER 表示：预加载。
name = “student_teacher” 指定关联关系表。
joinColumns = @JoinColumn(name = “student_id”) 指定我方在关联表中对应的主键。
inverseJoinColumns = @JoinColumn(name = “teacher_id”) 指定被维护方在关联表中对应的主键。
mappedBy = “teacherList” ：添加了这个属性表示放弃维护，维护方用来指向另一方的那个外键属性。

/**
 * 多对多
 * 维护方
 * 教师 外键
 * 级联关系为 none（没有，默认），双方互不干扰
 */
@ManyToMany(fetch = FetchType.EAGER)
@JoinTable(name = "student_teacher", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "teacher_id"))
private List<Teacher> teacherList;


/**
 * 多对多
 * 被维护方
 * 学生 外键（对应项）
 * 级联关系为 none（没有，默认），双方互不干扰
 */
@ManyToMany(mappedBy = "teacherList", fetch = FetchType.EAGER)
private List<Student> studentList;

/** 注意，外键及对应项的 Getter、Setter 不要忘了 */

本文参考

Spring Data JPA之一对一，一对多，多对多关系映射

下一篇：SpringDataJpa的使用 – 实体类序列化

十⑧
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Spring Boot JPA级联查询【一对多、多对一】
u014713873的博客
05-24 8119
一、数据准备 在管理系统中，角色和用户是典型一对多关系，一个角色可以分配给多个用户，一个用户对应一个角色。准备两个实体类TestRole、TestUser类，并在数据库建好对应表结构z_test_roles、z_test_users两张表。 @Entity @Getter @Setter @Table(name = "z_test_roles") public class TestRole implements Serializable { @Id @Column(na...
SpringBoot中使用jpa实现双向多对多(纯注解的实现方式)
编程学习者的博客
11-01 1641
当前环境：idea 、springboot 当前项目基于前面的项目：SpringBoot中使用jpa实现一对多(或者多对一)的处理(纯注解的实现方式) 1.简介 由于前面实现了多对一和一对多，所以在这里实现多对多双向的，但是如果配置双向的多对多，就会出现一个问题重写toString的问题，需要自定义toString,否者会出现栈溢出的问题! 一个学生可以获得多个角色，一个角色对应多个学生，这就产生...
SpringData JPA (二) 进阶 - JPA一对多、多对多
热门推荐
qq_36662478的博客
04-10 1万+
1 JPA中的主键生成策略   通过annotation（注解）来映射实体类和数据库表的对应关系,基于annotation的主键标识为@Id注解, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。   其中：JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO\color{red}{TABLE,SE...
JPA表间关系（多对多，一对多，多对一）
wflsyf的博客
03-15 1287
**AccountEntity：用户 RoleEntity：角色 Permission: 权限 一个用户只能有一个角色，而一个角色可以属于多个用户， 一个角色拥有多个权限，一个权限也可以被多个角色拥有 ** OneToMany(此时的角色就为一对多)，在多的一方中加入少的一方的Set集合。targetEntity 为关联的实体类。JoinColumn可减少中间表的生成，account_role_id为待会儿会在少的一方(AccountEntity)中生成的角色Id字段,referencedColumnNa
springboot jpa 一对一级联查询
weixin_43931625的博客
09-10 1445
springbootjpa一对一级联查询 **************************** 相关注解 @OneToOne：一对一级联注解 public @interface OneToOne { Class targetEntity() default void.class; CascadeType[] cascade() default {};...
jpa-onetomany-springboot-maven-mysql：使用Spring Boot，Maven和MySQL的JPA一对多关系映射示例
01-30
Spring Boot，Maven和MySQL的JPA一对多关系示例 指南 先决条件 JDK 1.8或更高版本 Maven 3或更高版本 MySQL 5.6或更高版本 叠放 Spring Data JPA Sprint Boot MySQL 跑 mvn spring-boot:run
SpringData+jpa一对一与一对多
05-12
SpringData+jpa 一对一...本文探讨了 SpringData+jpa 中的一对一和一对多关系设计，展示了如何使用 @OneToOne 和 @OneToMany 注解来维护复杂的关系模型。通过自定义外键和级联操作，我们可以灵活地管理复杂的关系模型。
bookManager：用于Spring Boot的Book Manager一对多关系项目
02-04
一对多双向关系映射带有Spring Boot的Java Web Services和RESTful API 本教程将引导您完成使用Spring Boot，Spring Data JPA，Lombok，H2和Swagger映射JPA / Hibernate一对多双向关系的步骤。 下表关系图说明了此...
整合Spring Data JPA1
08-03
Spring Data JPA 是 Spring Data 框架的一个重要组成部分，它为 Java 持久层提供了一种基于 JPA（Java Persistence API）的简单、高效的解决方案。JPA 是 Java 标准，用于管理关系数据库中的对象，它通过 ORM（对象...
详述 Spring Data JPA 的那些事.docx
最新发布
11-14
Spring Data JPA是一种基于Java Persistence API（JPA）的数据访问技术，它提供了一种简洁的方式来访问关系数据库。下面是对Spring Data JPA的详细知识点解释： 什么是JPA JPA全称为Java Persistence API，是Java...
jpa的一对多和多对多代码
07-28
主要就是如何实现一对多和多对多的代码
JPA中的一对多
qq_42836176的博客
12-04 3276
2.1 表之间关系的划分 数据库中多表之间存在着三种关系，如图所示。 从图可以看出，系统设计的三种实体关系分别为：多对多、一对多和一对一关系。注意：一对多关系可以看为两种： 即一对多，多对一。所以说四种更精确。 明确： 我们今天只涉及实际开发中常用的关联关系，一对多和多对多。而一对一的情况，在实际开发中几乎不用。 2.2 在JPA框架中表关系的分析步骤 在实际开发中，我们数据库的表难免会有相互...
Spring Boot 2.0之Spring Data和JPA
11-14
基于Spring Boot 2.0.2讲解了如何在Spring Boot中使用Spring Data和JPA。对于Spring Data主要讲解了几个Respository和自定义Respository；对于JPA主要讲解了几种关联关系，多对一、一对多、多对多等。
SpringBoot中使用jpa实现一对多(或者多对一)的处理(纯注解的实现方式)
编程学习者的博客
11-01 5972
当前环境：idea、springboot 1.简介 由于要求需要使用springboot中使用jpa来简化开发，但是对于一对多或者多对一的关系还是不够了解(由于是使用注解版的)。 所以这里使用了：一个学生对应一个班级，但是一个班级中具有多个学生，所以可以理解为：一个班级中具有一个许多学生(一个班级中具有一个学生集合)，一个学生属于一个班级 2.编写数据库 classes班级表中表结构： 学生表u...
Spring Data JPA 之 一对一，一对多，多对多 关系映射
loliDapao的博客
06-22 1168
springbootjpa映射
五、Spring Data JPA一对多操作
a2231476020的博客
06-26 1815
客户—>联系人（一对多） 客户Customer 实体类： @Entity @Table(name="cst_customer") public class Customer { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name="cust_id") private Lon...
Jpa 注解详解 映射详解 一对多 多对一
weixin_30824479的博客
07-31 572
Jpa映射详解 该博客例子均用 SpringBoot + Spring Data Jpa 实现 一、常用注解 这里主要介绍了最常用注解，实现POJO和数据库的隐射。 @Entity 对类注释。任何Hibernate映射对象都要有这个注释 持久层将对象映射到数据库，JPA是一种规范，Hibernate是一种实现，可以将POJO映射到数据库。这种类就叫Entity Bean @Table 对类注释...
Jpa 中怎么玩一对多？
江南一点雨的专栏
02-18 1715
Jpa 中的一对一、一对多没搞明白的话，总会觉得有点绕，今天咱们来简单聊聊这个话题。 1. 一对一 比如说一个学校有一个地址，一个地址只有一个学校。 那么我们可以按照如下方式来设计类： @Data @Entity @Table(name = "t_address") public class Address { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer aid; privat
Spring Data JPA和Mybatis的区别
07-12
Spring Data JPA和MyBatis是两种不同的持久化框架，它们在实现方式和使用上有一些区别。 Spring Data JPA是Spring框架提供的一种基于JPA（Java Persistence API）规范的持久化解决方案。它利用注解和接口的方式来定义数据访问层，通过继承和实现一些基本接口，可以自动生成常见的CRUD（创建、读取、更新、删除）方法。Spring Data JPA提供了很多便捷的功能，如分页、排序、动态查询等，可以大大简化数据库操作的编写工作。 MyBatis是一个轻量级的持久化框架，它是基于SQL语句的。在MyBatis中，通过编写SQL语句来实现数据库的访问操作，可以对SQL语句进行灵活的控制和优化。MyBatis提供了丰富的映射配置，可以将结果集映射到Java对象中，并支持动态SQL、分页、缓存等功能。相比于ORM框架，MyBatis更加灵活，可以更好地控制SQL语句的执行。 总体来说，Spring Data JPA更适合对于简单的CRUD操作进行快速开发，而MyBatis适合对SQL语句有更高要求、需要更灵活控制的场景。选择使用哪种框架，可以根据具体的项目需求、团队技术栈和个人偏好进行选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十⑧

你的鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值