Hibernate 教程（七）[一对多关系，多对一关系]

最新推荐文章于 2022-10-26 15:46:04 发布
最新推荐文章于 2022-10-26 15:46:04 发布
阅读量338 收藏 1
点赞数
分类专栏： Hibernate 文章标签： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/God_Father_kao/article/details/85340800
版权
准备

文章目录


一个班级对应多个学生
多个学生对应一个班级

@OneToMany

OneToMany API

CascadeType[]	cascade	
(可选)必须级联到关联目标的操作。

FetchType	fetch	
(可选)是否应该延迟加载关联，或者必须急切地获取关联。

java.lang.String	mappedBy
拥有关系的字段。

boolean	orphanRemoval
(可选)是否将删除操作应用于已从关系中删除的实体，以及是否将删除操作级联到这些实体。

java.lang.Class	targetEntity
(可选)作为关联目标的实体类。

@ManyToOne

ManyToOne API

CascadeType[]	cascade
(可选)必须级联到关联目标的操作。

FetchType	fetch
(可选)是否应该延迟加载关联，或者必须急切地获取关联。

boolean	optional
(可选)关联是否可选。

java.lang.Class	targetEntity
(可选)作为关联目标的实体类。

@JoinTable
JoinTable API

java.lang.String	catalog
(可选)表的目录。

ForeignKey	foreignKey
(可选)当表生成生效时，用于指定或控制与joinColumns元素对应的列的外键约束的生成。

Index[]	indexes
(可选)表的索引。

ForeignKey	inverseForeignKey
(可选)当表生成生效时，用于指定或控制与inverseJoinColumns元素对应的列的外键约束的生成。

JoinColumn[]	inverseJoinColumns
(可选)联接表的外键列，它们引用不拥有关联的实体的主表。

JoinColumn[]	joinColumns
(可选)联接表的外键列，它们引用拥有关联的实体的主表。

java.lang.String	name
(可选)联接表的名称。

java.lang.String	schema
(可选)表的模式。

UniqueConstraint[]	uniqueConstraints
(可选)要放在表上的惟一约束。

数据库数据

/*
 Navicat Premium Data Transfer

 Source Server         : 192.168.1.200
 Source Server Type    : MySQL
 Source Server Version : 80013
 Source Host           : 192.168.1.200:3306
 Source Schema         : Hibernate

 Target Server Type    : MySQL
 Target Server Version : 80013
 File Encoding         : 65001

 Date: 29/12/2018 15:36:49
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for class
-- ----------------------------
DROP TABLE IF EXISTS `class`;
CREATE TABLE `class`  (
  `classID` int(11) NOT NULL AUTO_INCREMENT COMMENT '唯一标识',
  `className` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '班级名',
  PRIMARY KEY (`classID`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of class
-- ----------------------------
INSERT INTO `class` VALUES (1, '火力班');
INSERT INTO `class` VALUES (2, '志成班');
INSERT INTO `class` VALUES (3, '自强班');
INSERT INTO `class` VALUES (4, '启航班');

-- ----------------------------
-- Table structure for class_student
-- ----------------------------
DROP TABLE IF EXISTS `class_student`;
CREATE TABLE `class_student`  (
  `studentID` int(11) NULL DEFAULT NULL,
  `classID` int(11) NULL DEFAULT NULL,
  INDEX `stu_fk`(`studentID`) USING BTREE,
  INDEX `cla_fk`(`classID`) USING BTREE,
  CONSTRAINT `cla_fk` FOREIGN KEY (`classID`) REFERENCES `class` (`classid`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `stu_fk` FOREIGN KEY (`studentID`) REFERENCES `student` (`studentid`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of class_student
-- ----------------------------
INSERT INTO `class_student` VALUES (1, 1);
INSERT INTO `class_student` VALUES (2, 1);
INSERT INTO `class_student` VALUES (3, 1);
INSERT INTO `class_student` VALUES (4, 1);
INSERT INTO `class_student` VALUES (5, 1);
INSERT INTO `class_student` VALUES (6, 2);
INSERT INTO `class_student` VALUES (7, 2);
INSERT INTO `class_student` VALUES (8, 2);
INSERT INTO `class_student` VALUES (9, 2);
INSERT INTO `class_student` VALUES (10, 2);
INSERT INTO `class_student` VALUES (11, 3);
INSERT INTO `class_student` VALUES (12, 3);
INSERT INTO `class_student` VALUES (13, 3);
INSERT INTO `class_student` VALUES (14, 3);
INSERT INTO `class_student` VALUES (15, 3);
INSERT INTO `class_student` VALUES (16, 4);
INSERT INTO `class_student` VALUES (17, 4);
INSERT INTO `class_student` VALUES (20, 4);
INSERT INTO `class_student` VALUES (18, 4);
INSERT INTO `class_student` VALUES (19, 4);

-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`  (
  `studentID` int(11) NOT NULL AUTO_INCREMENT COMMENT '唯一标识',
  `studentName` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '学生名',
  PRIMARY KEY (`studentID`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES (1, '贾德善');
INSERT INTO `student` VALUES (2, '彭万里');
INSERT INTO `student` VALUES (3, '高大山');
INSERT INTO `student` VALUES (4, '谢大海');
INSERT INTO `student` VALUES (5, '马宏宇');
INSERT INTO `student` VALUES (6, '林莽');
INSERT INTO `student` VALUES (7, '黄强辉');
INSERT INTO `student` VALUES (8, '章汉夫');
INSERT INTO `student` VALUES (9, '范长江');
INSERT INTO `student` VALUES (10, '林君雄');
INSERT INTO `student` VALUES (11, '谭平山');
INSERT INTO `student` VALUES (12, '朱希亮');
INSERT INTO `student` VALUES (13, '李四光');
INSERT INTO `student` VALUES (14, '甘铁生');
INSERT INTO `student` VALUES (15, '张伍绍祖');
INSERT INTO `student` VALUES (16, '马继祖');
INSERT INTO `student` VALUES (17, '程孝先');
INSERT INTO `student` VALUES (18, '宗敬先');
INSERT INTO `student` VALUES (19, '年广嗣');
INSERT INTO `student` VALUES (20, '汤绍箕');
INSERT INTO `student` VALUES (21, '吕显祖');
单向一对多

Class

package entity;

import java.util.Set;

import javax.persistence.CascadeType;
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.OneToMany;
import javax.persistence.Table;

@Table(name = "class")
@Entity
public class Class {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int classID;

	private String className;

	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	@JoinTable(name = "class_student", joinColumns = { @JoinColumn(name = "classID") }, inverseJoinColumns = {
			@JoinColumn(name = "studentID") })
	private Set<Student> students;

	public int getClassID() {
		return classID;
	}

	public void setClassID(int classID) {
		this.classID = classID;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public Set<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}

}

Student

package entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "student")
@Entity
public class Student {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int studentID;

	private String studentName;

	public int getStudentID() {
		return studentID;
	}

	public void setStudentID(int studentID) {
		this.studentID = studentID;
	}

	public String getStudentName() {
		return studentName;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

}
单向多对一
package entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "class")
@Entity
public class Class {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int classID;

	private String className;


	public int getClassID() {
		return classID;
	}

	public void setClassID(int classID) {
		this.classID = classID;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

}

package entity;

import javax.persistence.CascadeType;
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.ManyToOne;
import javax.persistence.Table;

@Table(name = "student")
@Entity
public class Student {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int studentID;

	private String studentName;

	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	@JoinTable(name = "class_student", joinColumns = { @JoinColumn(name = "studentID") }, inverseJoinColumns = {
			@JoinColumn(name = "classID") })
	private Class clazz;

	public int getStudentID() {
		return studentID;
	}

	public void setStudentID(int studentID) {
		this.studentID = studentID;
	}

	public String getStudentName() {
		return studentName;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

	public Class getClazz() {
		return clazz;
	}

	public void setClazz(Class clazz) {
		this.clazz = clazz;
	}

}
双向关系

（一对多，多对一）
只能从一端维护关系
Class

package entity.ManyToOne_OneTOMany;

import java.util.Set;

import javax.persistence.CascadeType;
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;

@Table(name = "class")
@Entity
public class Class {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int classID;

	private String className;
	
	@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="clazz")
	private Set<Student> students;

	public int getClassID() {
		return classID;
	}

	public void setClassID(int classID) {
		this.classID = classID;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public Set<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}

}

Student

package entity.ManyToOne_OneTOMany;

import javax.persistence.CascadeType;
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.ManyToOne;
import javax.persistence.Table;

@Table(name = "student")
@Entity
public class Student {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int studentID;

	private String studentName;

	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	@JoinTable(name = "class_student", joinColumns = { @JoinColumn(name = "studentID") }, inverseJoinColumns = {
			@JoinColumn(name = "classID") })
	private Class clazz;

	public int getStudentID() {
		return studentID;
	}

	public void setStudentID(int studentID) {
		this.studentID = studentID;
	}

	public String getStudentName() {
		return studentName;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

	public Class getClazz() {
		return clazz;
	}

	public void setClazz(Class clazz) {
		this.clazz = clazz;
	}

}
项目源码

https://download.csdn.net/download/god_father_kao/10885861

混世小萌羊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关系配置一对一_Jpa系列：SpringBoot Jpa 的表关系维护
weixin_32968105的博客
01-03 667
SpringBoot表关系依靠注解@OneToOne、@ManyToMany、@ManyToOne、@OneToMany来实现。注意：@OneToMany如果不加@JoinColumn,系统会自动在主从表中增加一个中间表。当数据记录较多时，会影响数据库的性能。其他三个注解情况也类似？（还没试验过）。1. @OneToOne：维护”一对一“关系@OneToOne注解维护的是表与表之间的“一对一”关系...
Hibernate 系列教程 单向一对多
11-30
在数据库设计中，一对多关系意味着一个父表记录可以与多个子表记录相关联。例如，一个学生可以有多个课程，或者一个部门可以有多名员工。在Hibernate中，这种关系可以通过配置XML映射文件或使用注解来实现。 首先，...
Hibernate使用外键ForeignKey
03-31
Hibernate使用外键的一个简单直接的例子，便于学习者很好地理解 DB 的配置操作
hibernate外键是否维护（inverse）的问题
羊羽的博客
05-15 2612
以下是个人经验小结，如有不当请指出！谢谢~ 1.在一对多的关系中，由于两表共用一个同名的外键，所以可以选择让其中一个表选择放弃维护外键就可以，也就是将"set"标签中的"inverse"属性设置为"true"（见下图）,这样节省系统资源，提高程序运行效率。 2.在多对多的关系中，由于两表在第三表中分别使用各自的外键，外键不同名，所以两个表的配置文件中都要设置维护外键
Java数据库foreign,java – 当我有@ManyToMany时如何设置ForeignKey...
weixin_39594191的博客
03-13 250
我正在使用JPA类创建数据库.如果我们有ManyToOne关系,我们可以覆盖ForeignKey名称,如下所示：@ManyToOne@JoinColumn(foreignKey = @ForeignKey(name = "FK_COUNTRY"))private Country country;在DB中,我们将得到如下结果：好的,那很好好的结果！但是当我有@ManyToMany时,我不会设置自己的...
史上最简单的JPA关联教程
林老师带你学编程
01-26 3395
JPA关联查询 因为项目中我们用到的都是双向管理关系，所以这边单向的我就不多做介绍。 我们这边接着上一节的课程继续介绍，这边我新建了Goods,GoodsDetail,Classify,Address四个实体映射类。分别进行一对一，一对多，多对多的关联介绍。 1.首先是一对一关系介绍，这边一对一的关系分别是Goods和GoodsDetail（商品表和商品详细表） 关联的注释
Hibernate教程之六一对多&多对一实现基于xml和注解
零学IT
07-21 413
在上一篇博客中我们知道数据库的三种关系，那么这一篇就聊聊一对多的关系。 一对多的时候，需要明确外键究竟应该设置到那个表上，一般都是多的那个表中拥有一的表的主键来做外键。 人和银行卡，一个人有多张银行卡，多张卡属于一个人，那么这2个表就存在一对多和多对一的关系。 首先我们看看基于xml的实现： Person类：//人类--体现一对多，一个人有多张银行卡 public class Person
在 JPA 和Hibernate中映射一对多和多对一关系的 3 种方法
最新发布
allway2的博客
10-26 541
有 3 种方法可以使用 @OneToMany 和 @ManyToOne来映射 JPA 和 Hibernate 中的一对多和多对一关系，包括。@JoinColumn指定单向@OneToMany的外键列是必需的。在本文中，我们快速浏览了在JPA和Hibernate中映射一到多和多对一关系的各种方法，以及有关其优缺点的说明。@ManyToOne将放置在实体（或关系所有者，基础数据库中具有外键列的表）的单个项目关联上。@OneToMany将放置在具有@JoinColumn且没有映射的实体（或单侧）的子集合上。
使用Hibernate操作一对多关系
ljheee的博客
09-20 4194
Hibernate介绍：http://blog.csdn.net/ljheee/article/details/52475798 Hibernate操作一对一关系：http://blog.csdn.net/ljheee/article/details/52593662 Hibernate操作一对多关系：         "一对多"是最普遍的映射关系，简单来讲就如产品和类别的关系。一个类别下可
Hibernate教程之五一对一实现基于xml和注解
零学IT
07-21 401
我们知道关系型数据库对表之间的关系，存在三种情况，哪三种嘞？ 1、一对一 A表数据和B表数据存在一一对应 2、一对多/多对一 一对多：A表中的一条数据对应B表的多条数据 多对一：B表多条数据对应A表的一条数据 3、多对多 A表的一条数据对应B表的多条数据 B表的一条数据对应A表的多条数据 其中又有单向和双向之分 何谓单双向，单就是一个中拥有另一个，双就是彼此拥有 那么我们下面就
在 JPA 和Hibernate中映射多对多关系的 6 种方法
allway2的博客
10-26 529
连接实体将使用 1 个用 @EmbeddedId 标记@Embeddable对象字段和 2 个用@MapsId标记的@ManyToOne来定义，这些字段指向@Embeddable类中定义的关键字段。在双向映射的情况下，如果需要快速导航并将 CRUD 操作级联到子集合关联，请将@OneToMany放在父实体上，如上述方法 2。有几种方法可以通过使用@ManyToMany、@OneToMany和@ManyToOne来映射 JPA 和Hibernate中的多对多关系，包括。此映射不会使用任何联接的实体。
Hibernate教程11_关系映射之一对多单向关联
04-13
本教程主要探讨的是Hibernate中的一种重要关系映射类型：一对多单向关联。在关系型数据库中，一对多关联是最常见的关系类型，一个实体可以与多个其他实体相关联。在Hibernate中，这种关系可以通过配置XML映射文件或...
Hibernate教程10_关系映射之多对一单向关联
04-13
本教程主要聚焦于Hibernate中的一个关键概念——关系映射，特别是多对一单向关联的实现。这种关联类型常出现在数据库设计中，比如一个部门可以有多名员工，但一个员工只属于一个部门。 首先，我们要理解多对一关系...
Hibernate ORM - 一对多双向关联关系
03-28
在数据库设计中，一对多关系意味着一个表的记录可以与另一个表的多个记录相关联。在Hibernate中，这种关系可以通过`@OneToMany`注解实现。例如，User类可能会有如下注解： ```java @Entity public class User { @...
hibernate多对一关联demo
09-20
本教程将详细解释如何在Hibernate中实现多对一的关联关系，以及如何通过一个实际的示例来演示这一过程。 【描述】：“博客地址：http://blog.csdn.net/smilefyx/article/details/48603923” 在上述博客文章中，...
Java EE实用教程（ 第 3 版 ）Hibernate 实验二【在Hibernate中实现一对多关联关系的映射】
超逸の学习技术博客
11-29 530
在某电子商务系统中商品类别(ProductType)和商品(Product)之间存在一对多关联，一个商品类别可包含多种商品。商品类别表包括类别编号(TID)、类别名称(TName)等属性，商品表包括商品编号(PID)、商品名称(PName)、商品价格(PPrice)、商品描述(PDescription)等属性。 现采用多对一单向关联方式，在Hibernate中实现一对多关联关系的映射，要求编写客...
Hibernate使用JPA，整合Druid连接池
God_Father_kao的博客
02-13 2497
Hibernate使用JPA，整合Druid连接池Hibernate了解Druid了解Hibernate配置总结 Hibernate了解 ps:官方文档说，这个配置是用来获取JDBC连接，只要实现了ConnectionProvider接口 源码： /* * Hibernate, Relational Persistence for Idiomatic Java * * License: G...
Hibernate 教程（五）[Criteria使用]
God_Father_kao的博客
12-25 598
Criteria Criteria 只支持查询，而且很难用，反正挺恶心的。我是这么觉得，别碰我。 但是Hibernate推荐这么做，我搞不懂 Criteria 查询数据 package query.Criteria; import java.util.Arrays; import java.util.List; import javax.persistence.Tuple; import ja...
Hibernate 教程（六）[一对一关系]
God_Father_kao的博客
12-29 492
一对一关系 准备 使用注解配置一对一关系 需要用到的注解 @OneToOne ( CascadeType[] cascade (可选)必须级联到关联目标的操作。 FetchType fetch (可选)是否应该延迟加载关联，或者必须急切地获取关联。 java.lang.String mappedBy (可选)拥有关系的字段。 boolean optional (可选)关联是否可选。 boo...
HIBERNATE - 符合Java习惯的关系数据库持久化.docx
05-05
"这篇文档是关于Hibernate的详细教程，涵盖了从入门到高级特性的使用，包括如何创建第一个Hibernate应用程序、关联映射、架构解析、配置、持久化类等多个方面。" Hibernate是Java开发中广泛使用的一个对象关系映射...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值