Hibernate从零开始_07_多对多关系（中间表）

最新推荐文章于 2023-07-05 09:00:00 发布
最新推荐文章于 2023-07-05 09:00:00 发布
阅读量474 收藏
点赞数
分类专栏： SSH
 1、Hibernate多对多（中间表含多个字段）的把多对多拆分为两个一对多。实现如下：

    学生类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
  * 学生表
  */
public  class  Student {
  private  Long id;
  private  String name;
  
  //与学生课程关联表建立一对多关系
  private  Set<StudentCourseRelation> scr =  new  HashSet<StudentCourseRelation>();
  
  public  Student() {
  }
  public  Long getId() {
   return  id;
  }
  public  void  setId(Long id) {
   this .id = id;
  }
  public  String getName() {
   return  name;
  }
  public  void  setName(String name) {
   this .name = name;
  }
  public  Set<StudentCourseRelation> getScr() {
   return  scr;
  }
  public  void  setScr(Set<StudentCourseRelation> scr) {
   this .scr = scr;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<? xml  version = "1.0"  encoding = "UTF-8" ?>
<! DOCTYPE  hibernate-mapping PUBLIC   
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  < hibernate-mapping >
   < class  name = "com.study.hibernate.domain.Student"  table = "t_student"  catalog = "db_hibernate" >
    < id  name = "id"  column = "id"  type = "java.lang.Long" >
     < generator   class = "native" ></ generator >
    </ id >
    
    < property  name = "name"  column = "name"  type = "java.lang.String" ></ property >
    
    
    < set  name = "scr"  cascade = "all" >
     < key  column = "student_id" />
     < one-to-many  class = "com.study.hibernate.domain.StudentCourseRelation" />
    </ set >
   </ class >
  </ hibernate-mapping >

    课程类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
  * 课程
  */
public  class  Course {
  private  Long id;
  private  String name;
  
  //与学生课程关联表建立一对多关系
  private  Set<StudentCourseRelation> scr =  new  HashSet<StudentCourseRelation>();
  
  public  Course(){
   
  }
  
  public  Long getId() {
   return  id;
  }
  public  void  setId(Long id) {
   this .id = id;
  }
  public  String getName() {
   return  name;
  }
  public  void  setName(String name) {
   this .name = name;
  }
  public  Set<StudentCourseRelation> getScr() {
   return  scr;
  }
  public  void  setScr(Set<StudentCourseRelation> scr) {
   this .scr = scr;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<? xml  version = "1.0"  encoding = "UTF-8" ?>
<! DOCTYPE  hibernate-mapping PUBLIC   
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  < hibernate-mapping >
   < class  name = "com.study.hibernate.domain.Course"  table = "t_course"  catalog = "db_hibernate" >
    < id  name = "id"  column = "id"  type = "java.lang.Long" >
     < generator   class = "native" ></ generator >
    </ id >
    < property  name = "name"  column = "name"  type = "java.lang.String" ></ property >
    < set  name = "scr"  cascade = "all" >
     < key  column = "course_id" />
     < one-to-many  class = "com.study.hibernate.domain.StudentCourseRelation" />
    </ set >
   </ class >
  </ hibernate-mapping >

    学生课程关联类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
  * 学生课程关联表
  */
public  class  StudentCourseRelation {
  private  Long id;
  private  Long sort;
  private  Student students;
  private  Course courses;
  
  public  Long getId() {
   return  id;
  }
  public  void  setId(Long id) {
   this .id = id;
  }
  
  public  Long getSort() {
   return  sort;
  }
  public  void  setSort(Long sort) {
   this .sort = sort;
  }
  public  Student getStudents() {
   return  students;
  }
  public  void  setStudents(Student students) {
   this .students = students;
  }
  public  Course getCourses() {
   return  courses;
  }
  public  void  setCourses(Course courses) {
   this .courses = courses;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<? xml  version = "1.0"  encoding = "UTF-8" ?>
<! DOCTYPE  hibernate-mapping PUBLIC   
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  < hibernate-mapping >
   < class  name = "com.study.hibernate.domain.StudentCourseRelation"  table = "t_student_course_relation"  catalog = "db_hibernate" >
    < id  name = "id"  column = "id"  type = "java.lang.Long" >
     < generator   class = "native" ></ generator >
    </ id >
    < property  name = "sort"  column = "sort"  type = "java.lang.Long" ></ property >
    < many-to-one  name = "students"  class = "com.study.hibernate.domain.Student"  column = "student_id" ></ many-to-one >
    < many-to-one  name = "courses"  class = "com.study.hibernate.domain.Course"  column = "course_id" ></ many-to-one >
   </ class >
  </ hibernate-mapping >

    测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
   * 插入数据
   */
  @Test
  public  void  insertTest(){
   Configuration configuration =  new  Configuration().configure();
   ServiceRegistry serviceRegistry =  new  ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
   SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
   Session session = sessionFactory.openSession();
   Transaction transaction = session.beginTransaction();
   
   Student stu1 =  new  Student();
   stu1.setName( "zhangsan" );
   
   Course c1 =  new  Course();
   c1.setName( "English" );
   
   session.persist(stu1);
   session.persist(c1);
   
   StudentCourseRelation scr =  new  StudentCourseRelation();
   scr.setStudents(stu1);
   scr.setCourses(c1);
   session.persist(scr);
   transaction.commit();
   session.close();
   sessionFactory.close();
   
   //结果
//  Hibernate: /* insert com.study.hibernate.domain.Student */ insert into db_hibernate.t_student (name) values (?)
//  Hibernate: /* insert com.study.hibernate.domain.Course */ insert into db_hibernate.t_course (name) values (?)
//  Hibernate: /* insert com.study.hibernate.domain.StudentCourseRelation */ insert into db_hibernate.t_student_course_relation (student_id, course_id) values (?, ?)
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  /**
   * 查询数据
   */
  @Test
  public  void  queryTest(){
   Configuration configuration =  new  Configuration().configure();
   ServiceRegistry serviceRegistry =  new  ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
   SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
   Session session = sessionFactory.openSession();
   Transaction transaction = session.beginTransaction();
   
   
   Student stu = (Student) session.load(Student. class ,  new  Long( 2 ));
   Set<StudentCourseRelation> scr =  stu.getScr();
   for  (StudentCourseRelation studentCourseRelation : scr) {
    System.out.println(studentCourseRelation.getCourses().getId());
    System.out.println(studentCourseRelation.getCourses().getName());
   }
   
   
   transaction.commit();
   session.close();
   sessionFactory.close();
  }

    结果：

1
2
3
4
Hibernate:  /* load com.study.hibernate.domain.Student */  select student0_.id as id1_1_0_, student0_.name as name2_1_0_ from db_hibernate.t_student student0_ where student0_.id=?
Hibernate:  /* load one-to-many com.study.hibernate.domain.Student.scr */  select scr0_.student_id as student_3_1_1_, scr0_.id as id1_2_1_, scr0_.id as id1_2_0_, scr0_.sort as sort2_2_0_, scr0_.student_id as student_3_2_0_, scr0_.course_id as course_i4_2_0_ from db_hibernate.t_student_course_relation scr0_ where scr0_.student_id=?
Hibernate:  /* load com.study.hibernate.domain.Course */  select course0_.id as id1_0_0_, course0_.name as name2_0_0_ from db_hibernate.t_course course0_ where course0_.id=?
2 :English
judyge
关注
专栏目录
Redis框架从入门到学精（全）
码农研究僧的博客
07-02 2万+
目录前言1.NoSQL2.Redis2.1 软件安装数据类型 前言 解决功能新问题：JAVA jsp rdsms tomcat html linux jdbc svn 解决发展性问题：strtus spring springmvc hibernate mybatis 解决性能问题：NOSQL java 线程 hadoop nginx mq elasticsearch 1.NoSQL NoSQL特点 非关系型数据库，不依赖业务逻辑数据库存储，以简单key-value存储 适用于 ~高并发读写 ~海量数据读
hibernate之多对多映射操作中间表
cst_code的博客
05-01 7832
hibernate之多对多映射操作中间表
关于《hibernate多对多》有中间表的建立
weixin_30580943的博客
12-27 136
角色 与 菜单（资源）的多对多关系，在这里我们建立中间表，用两个oneToMany实现 实体类： 　　角色（GmRole） 菜单（GmMenu） 中间表（GmRoleRight） 1.在角色实体中 package com.bossy.gun.entity; import java.util.HashSet; import java.util.Set; import java...
如何利用hibernate 多对 多，操作中间表
zhuwentaolove的专栏
10-06 314
利用hibernate解决多对多的问题 1建立实体多对多关系Manytomany，利用hibernate去维护多对多关系，但是hibernate无提供中间表操作。 2在1的基础上，建立中间表，利用一对多关系。 这样可以在中间表添加其他属性，也可以利用hibernate多对多去维护 EG： 学生：ID,name 学科：ID，classname 中间表：sid，cid，S...
Hibernate (2) --多对多 中间表设计及映射
fengcai0123的专栏
07-17 609
数据库设计：good表（主键good_id），user表（主键user_id）情况一：中间表user_good只有两个字段：good_id,user_id. good与user只是多对多（manyToMany）的关系 注解形式的映射如下：public class Good{ //被维护端 @ManyToMany(mappedBy = "goods") private Set
hibernate多对多中间表的操作
cowwen的专栏
02-17 274
Intro It is not straightforward to realise a many-to-many association with JPA when in the join table there is at least an extra column. In this small tutorial I’m going to show how to design entity ...
从零开始 Spring Boot 58：JPA中的多对多关系
最新发布
梦幻天空
07-05 800
一般来说，我们用第一种方式即可，不用为中间实体建模会让关系复杂度降低。但如果需要中间实体保存某些信息，我们就不得不为中间实体建模。本文的完整示例可以从这里获取。
从零开始使用IDEA搭建Springboot+JPA+Swagger2.0+Logback+Lombok+Redis+Shiro1.4项目（二）
online8023you的博客
07-30 549
从零开始使用IDEA搭建Springboot+jpa+swagger2.0+logback+lombok+redis+shiro1.4项目（二）连接数据库准备工作配置文件配置 pom.xml 文件配置 application.yml 文件创建各个层对应的文件夹代码工作创建对应的实体类UserRoleAuthority添加关系映射UserRoleAuthority创建 dao 接口UserRepos...
java-spring-fast-base_java_springboot_swagger_jpaspring_micromet
10-04
【标题】"java-spring-fast-...通过这个模板，开发者可以节省时间，专注于实现具体业务需求，而不用从零开始配置整个环境。同时，由于集成了Swagger和Micrometer，开发者可以更加方便地测试API并了解应用的运行状况。
hibernate 多表关联 中间表
11-14
hibernate 中间表 希望给予新手帮助
hibernate多对多中间表问题
keke_Xin的专栏
07-09 192
hibernate 多对多 中间表ID生成方式 定稿 其实大家都没理解我的意思。我是说在hibernate多对多的关系中，中间表是不需要生成配置文件和POJO的。所有如果存在ID主键，hibernate是不能向中间表插入主键的除非多对多配置成两个1对多，并且生成中间表的配置文件这样不是我想要的。现在我搞明白了如果中间表生成配置文件，那配置成2个一对多进行关联。如果单纯的多对多关系不生成中间表...
Hibernate使用中间表完成单向多对多关联关系的配置和级联操作示例
花飘万家雪
10-17 1115
有两个原本没有关系的
Hibernate 中间表的配置方式
01-02 516
有三张表 表一 tab1 {    id   int(11) primary key,    name  varchar(20) } 表二 tab2 {    id int(11) primary key,    role varchar(10),    desc varchar(200) } 中间表 tab3 {    id int(11) primary key,    tb1_id f
hibernate多对多之中间表有多个字段
u014038534的专栏
12-02 2096
ame = name;  }  @Column(name = "sex")  public int getSex() {   return sex;  }  public void setSex(int sex) {   this.sex = sex;  }  @OneToMany(mappedBy = "teacher",cascade=CascadeType.ALL)  p
Hibernate 关系映射(二)基于中间表的N:1
路虽远行则将至，事虽难做则必成
03-27 534
1.单向 N:1 有中间表 例如:一个地方有多个人住.      每个同学记住老师,比老师记住每个同学简单. (在 n 的一端进行配置效率高) N            1 Person   : Address Student  : Teacher 注意:这次是有中间表 注意:比较 有无中间表的 配置,发现 采用 Join 和 many-to-one 进行配置 中间表 Person
hibernate之表关系中的多对多
u011266694的专栏
12-11 206
多对多示例： 多对多和一对多基本相同，配置文件稍有区别，需要指定中间表，和中间表中两表的外键 注意的是：多对多两方同时维护关系，会导致中间表中插入重复数据。而一对多两方同时维护关系，只会导致多余的sql（维护关系实质在代码中指：setCustomer(customer),customer.getLinkMens().add(linkMan),这些建立对象关联的代码）   多对多JavaBe
Hibernate 多对多 中间表含有其他字段 注解方式实现
GeekLei
01-28 4520
Hibernate 多对多 中间表含有其他字段 注解方式实现
hibernate 多对多关系详解(包括中间表，一对多字表)
kenchow126的专栏
05-25 8004
Event事件表 Person 人员表 Person_Event 人员事件表 PersonEmailAddr邮件地址表  关系图： 事件对人员是多对多的关系，中间表Person_Event只有两个字段(PERSON_ID,EVENT_ID)，邮件地址表只对应人员ID，一个人可以多个邮箱   *************** CLASS PERSON ***************
双向多对多关系映射及中间表插入示例
"双向多对多关系在数据库中通常通过中间表来实现，本文提供了一个具体的插入数据到中间表的实例。" 在数据库设计中，当两个实体之间存在多对多的关系时，为了存储这种复杂的关系，我们需要创建一个中间表来连接这两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值