SpringDataJpa的使用之一对一、一对多、多对多关系映射问题

2024-10-01 15:53:09

项目依赖
项目配置
sql文件（MySQL版）
级联关系简述
@OneToOne 一对一关系映射
1.无中间表，维护方添加外键，被维护方添加对应项
2.无中间表，维护方添加外键，被维护方不添加对应项
3.有中间表，维护方不添加外键，被维护方不添加对应项
@OneToMany、@ManyToOne 一对多关系映射
1.无中间表，多方维护并添加外键，一方被维护
2.有中间表，多方维护，一方被维护
3.无中间表，多方维护，一方也维护
@ManyToMany 多对多关系映射
本文参考

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的使用之一对一、一对多、多对多关系映射的文章就介绍到这了,更多相关SpringDataJpa使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

使用SpringDataJpa创建中间表

目录 SpringDataJpa创建中间表 JPA中间表(关系表)联合主键配置说明问题场景数据表结构实体代码 idClass类代码实体类最终正确代码持久层配置 SpringDataJpa创建中间表 //fetch=FetchType.EAGER 关闭懒加载相当于hibernate中的lazy=false //joinColumns 配置中间表的主列 //inverseJoinColumns=@JoinColumn(name="t_roleId") 创建中间表的副列 @Man
SpringDataJpa如何使用union多表分页条件查询

目录如何使用union多表分页条件查询条件分页踩过的坑分享几个用到的mysql语法 jpa执行原生sqlunionbug解决如何使用union多表分页条件查询当前项目有一个全局搜索的功能,需要涉及到7-8张主表,由于当前项目使用的是Jpa,所以我决定使用原生sql的方式使用union来进行查询,由于对这个框架的不熟悉,被坑了很久,特此记录. 条件 1.在参数列表中,使用@Param注解(例:@Param(“userId”) Long userId) 2.在sql中应该以 :user
SpringDataJPA实体类关系映射配置方式

目录 SpringDataJPA 1.单向一对一映射 2.双向一对一映射 3.单向一对多映射 4.双向一对多映射 5.单向多对一映射 6.双向多对一映射 7.单向多对多映射 8.双向多对多映射 SpringDataJPA //FetchType.LAZY:懒加载,加载一个实体时,定义懒加载的属性不会马上从数据库中加载 //FetchType.EAGER:急加载,加载一个实体时,定义急加载的属性会立即从数据库中加载 //cascade = CascadeType.ALL 表示所有情况下均进行关联操
SpringDataJpa的使用之一对一、一对多、多对多关系映射问题

目录 SpringDataJpa的使用 -- 一对一.一对多.多对多关系映射项目依赖项目配置 sql文件(MySQL版) 级联关系简述 @OneToOne 一对一关系映射 1.无中间表,维护方添加外键,被维护方添加对应项 2.无中间表,维护方添加外键,被维护方不添加对应项 3.有中间表,维护方不添加外键,被维护方不添加对应项 @OneToMany.@ManyToOne 一对多关系映射 1.无中间表,多方维护并添加外键,一方被维护 2.有中间表,多方维护,一方被维护 3.无中间表,多方维
Hibernate的一对一,一对多/多对一关联保存的实现

目录一对一关联保存: 留言表实体类配置:(主表) 留言内容表配置:(从表) 留言表hbm.xml配置:(主表) 留言内容表hbm.xml配置:(从表) 一对多/多对一保存活动表实体类配置:(主表) 自定义报名要素实体类配置:(从表) 活动表hbm.xml配置:(主表) 报名信息表:(从表) 一对一关联保存: 说明: 留言状态表: 记录用户的留言信息,如留言人openid,留言时间等-(主表) 用户留言内容表: 记录用户的留言内容,id与状态表一对一(从表) 留言表实体类配置:(主表) 添加一
Django数据映射(一对一,一对多,多对多)

目录数据表关联关系映射一对一映射用法示例一对多映射用法示例多对多映射用法示例数据表关联关系映射常用的表关联方式有三种: 一对一映射如: 一个身份证对应一个人一对多映射如: 一个班级可以有多个学生多对多映射如: 一个学生可以报多个课程,一个课程可以有多个学生学习一对一映射一对一是表示现实事物间存在的一对一的对应关系. 如:一个家庭只有一个户主,一个男人有一个妻子,一个人有一个唯一的指纹信息等语法 class A(model.Model): ... class B(mod
Django中数据库的数据关系:一对一,一对多,多对多

一对一: 一对一的关系极为一个数据仅对应一个数据,用下图的结构图可以帮助理解: 下面用代码实现一下,首先要创建工程项目如下: 接着,我们定义模型: 来到models.py文件,创建两个模型: from django.db import models # Create your models here. class One(models.Model): oname = models.CharField(max_length=20,null=True) oage = models.CharField
Mybatis 中的一对一,一对多,多对多的配置原则示例代码

什么是 MyBatis ? MyBatis 是支持定制化 SQL.存储过程以及高级映射的优秀的持久层框架.MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集.MyBatis 可以对配置和原生Map使用简单的 XML 或注解,将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录. 表:market_plan(营销计划(关联了用户)) market_plan_product(产品关联营销计划) mark
springboot整合mybatis-plus基于注解实现一对一(一对多)查询功能

因为目前所用mybatis-plus版本为3.1.1,感觉是个半成品,所有在实体类上的注解只能支持单表,没有一对一和一对多关系映射,且该功能还在开发中,相信mybatis-plus开发团队在不久的将来应该会实现此功能. 由于本人开发习惯的原因,实在是太讨厌大量的xml充斥在整个项目中,尤其是表的mapper.xml,虽然有代码生成器可以生成,但是有些复杂的查询还是需要手写配置文件里的动态sql,这点比较反感(至于为什么反感,也是有多方面原因的). 不过可能是大量的java开发人员已经被虐惯了,已
PHP laravel中的多对多关系实例详解

数据表之间是纵横交叉.相互关联的,laravel的一对一,一对多比较好理解,官网介绍滴很详细了,在此我就不赘述啦,重点我记下多对多的关系一种常见的关联关系是多对多,即表A的某条记录通过中间表C与表B的多条记录关联,反之亦然.比如一个用户有多种角色,反之一个角色对应多个用户. 为了测试该关联关系,我们沿用官网的用户角色示例: 需要三张数据表:users.roles 和 role_user,role_user 表按照关联模型名的字母顺序命名(这里role_user是中间表),并且包含 user_i
关于多对多关系表无法更新与插入的问题

在EF里,我们设计模型时,会设计到多对多关系,在EF里会把这种关系会转成两个一对多的关系表,这是比较友好的,因为多对多来说,对于业务本身没什么意思,所以隐藏了,没什么坏处,但对于这个隐藏来说,对开发人员来讲你就无法主动控制这张关系表了,而需要使用EF的update来更新主表的同时去更新关系表,这对于初学者会出现一些问题,今天说的就是多对多关系无法更新和插入的问题．数据结构 public partial class WebManageRoles : Lind.DDD.Domain.Entity
django ManyToManyField多对多关系的实例详解

Django 的 ORM 有多种关系:一对一,多对一,多对多各自定义的方式为 : 一对一: OneToOneField 多对一: ForeignKey 多对多: ManyToManyField 上边的描述太过数据而缺乏人性化,我们来更人性化一些: 多个属于一个,即 belong to : ForeignKey,多个属于一个一个有一个,即 has one: OneToOneField 一个有很多个,即 has many: lots of A belong to B 与 B has many A
详解hibernate双向多对多关联映射XML与注解版

双向多对多关联映射原理: 假设,一个员工可能有多个角色,一个角色可能有多个员工,从员工或角色的角度看,这就是多对多的关系,不管从哪一个角度看,都是多对多的联系.多对多关联映射关系一般采用中间表的形式来实现,即新增一种包含关联双方主键的表.实现多对多关联关系,在数据库底层通过添加中间表指定关联关系,而在hibernate框架在双方的实体中添加一个保存对方的集合,在双方的映射文件中使用<set>元素和<many-to-many>元素进行关联关系的配置. 如下图所示: (1)XML版 R

SpringDataJpa的使用之一对一、一对多、多对多 关系映射问题

目录

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

项目依赖

项目配置

sql文件（MySQL版）

级联关系简述

@OneToOne 一对一 关系映射

1.无中间表，维护方添加外键，被维护方添加对应项

2.无中间表，维护方添加外键，被维护方不添加对应项

3.有中间表，维护方不添加外键，被维护方不添加对应项

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

1.无中间表，多方维护并添加外键，一方被维护

2.有中间表，多方维护，一方被维护

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

@ManyToMany 多对多 关系映射

本文参考

相关推荐

随机推荐

SpringDataJpa的使用之一对一、一对多、多对多关系映射问题

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

@OneToOne 一对一关系映射

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

@ManyToMany 多对多关系映射