Hibernate中多对多的annotation的写法（中间表可以有多个额外添加的字段）

最新推荐文章于 2022-06-23 10:46:45 发布
最新推荐文章于 2022-06-23 10:46:45 发布
阅读量1.2k 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/38982405
版权

方案一   中间表联合主键，自动生成

一般情况下，多对多的关联关系是需要中间表的；

情况一：如果中间表仅仅是做关联用的，它里面仅有2个外键做联合主键，则使用ManyToMany（不用写中间表的Model，只需要写出两张主表的model即可）

学生表

@Entity
@Table(name = "T_STUDENT")
@SequenceGenerator(name = "SEQ_STUDENT", sequenceName = "SEQ_STUDENT")
public class Student implements Serializable {
private static final long serialVersionUID = 2524659555729848644L;
private Long id;
private String name;
private Date birthday;
private int sex;
private String address;
private Set<Teacher> teacherList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_STUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.DATE)
@Column(name = "BIRTHDAY")
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@Column(name = "address")
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "T_TEACHER_STUDENT",
joinColumns = @JoinColumn(name = "student_id"),
inverseJoinColumns = @JoinColumn(name = "teacher_id"))
public Set<Teacher> getTeacherList() {
return teacherList;
}
public void setTeacherList(Set<Teacher> teacherList) {
this.teacherList = teacherList;
}
}

教师表

@Entity
@Table(name = "T_TEACHER")
@SequenceGenerator(name = "SEQ_TEACHER", sequenceName = "SEQ_TEACHER")
public class Teacher implements Serializable {
private static final long serialVersionUID = 2297316923535111793L;
private Long id;
private String name;
private int sex;
private Set<Student> studentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHER")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@ManyToMany(mappedBy = "teacherList", cascade = CascadeType.ALL)
public Set<Student> getStudentList() {
return studentList;
}
public void setStudentList(Set<Student> studentList) {
this.studentList = studentList;
}
}

hibernate.cfg.xml配置2个class类

<mapping class="com.dvn.li.model.Student"/>
<mapping class="com.dvn.li.model.Teacher"/>

测试：

SessionFactory sessionFactory = null;
Session session = null;
try {
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
session.beginTransaction();
Student s = new Student();
s.setName("小猪");
Teacher t = new Teacher();
t.setName("小李");
Set<Teacher> t_set = new HashSet<Teacher>();
t_set.add(t);
s.setTeacherList(t_set);
session.save(s);

} catch (Exception e) {
if (session != null) {
session.getTransaction().rollback();
}
}

测试通过！！！

很简单吧！注意HibernateUtil.getSessionFactory()的实现如下：

public class HibernateUtil {
private static final SessionFactory sessionFactory;

static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new AnnotationConfiguration().configure()
.buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}

如果自己做测试，可以通过SchemaExport导入表结构

SchemaExport export = new SchemaExport(new AnnotationConfiguration()
.configure());
export.create(true, true);

 


方案二   中间表中需要添加额外的字段


情况二：如果中间表不仅仅是做关联用的，它里面包含了其他字段信息，仅仅靠多对多的关系是搞不定的。

解决方案：多对多的关系拆分为两个一对多！这时候三张表的Model都需要写。

我们知道，一对多的关系，一般都是在多的一方做配置。具体代码如下：

学生表

@Entity
@Table(name = "T_STUDENT")
@SequenceGenerator(name = "SEQ_STUDENT", sequenceName = "SEQ_STUDENT")
public class Student2 implements Serializable {
private static final long serialVersionUID = 2524659555729848644L;
private Long id;
private String name;
private Date birthday;
private int sex;
private String address;
private Set<TeacherStudent> teacherStudentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_STUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.DATE)
@Column(name = "BIRTHDAY")
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@Column(name = "address")
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@OneToMany(mappedBy="student",cascade=CascadeType.ALL)
public Set<TeacherStudent> getTeacherStudentList() {
return teacherStudentList;
}
public void setTeacherStudentList(Set<TeacherStudent> teacherStudentList) {
this.teacherStudentList = teacherStudentList;
}
}

教师表

@Entity
@Table(name = "T_TEACHER")
@SequenceGenerator(name = "SEQ_TEACHER", sequenceName = "SEQ_TEACHER")
public class Teacher2 implements Serializable {
private static final long serialVersionUID = 2297316923535111793L;
private Long id;
private String name;
private int sex;
private Set<TeacherStudent> teacherStudentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHER")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@OneToMany(mappedBy = "teacher",cascade=CascadeType.ALL)
public Set<TeacherStudent> getTeacherStudentList() {
return teacherStudentList;
}
public void setTeacherStudentList(Set<TeacherStudent> teacherStudentList) {
this.teacherStudentList = teacherStudentList;
}
}

中间表

@Entity
@Table(name = "T_TEACHERSTUDENT")
@SequenceGenerator(name = "SEQ_TEACHERSTUDENT", sequenceName = "SEQ_TEACHERSTUDENT")
public class TeacherStudent implements Serializable {
private Long id;
private Student2 student;
private Teacher2 teacher;
private String note1;
private String note2;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHERSTUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "note1")
public String getNote1() {
return note1;
}
public void setNote1(String note1) {
this.note1 = note1;
}
@Column(name = "note2")
public String getNote2() {
return note2;
}
public void setNote2(String note2) {
this.note2 = note2;
}
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name = "student_id", unique = true)
public Student2 getStudent() {
return student;
}
public void setStudent(Student2 student) {
this.student = student;
}
@ManyToOne
@JoinColumn(name = "teacher_id", unique = true)
public Teacher2 getTeacher() {
return teacher;
}
public void setTeacher(Teacher2 teacher) {
this.teacher = teacher;
}
}

hibernate.cfg.xml 引入对象

<mapping class="com.dvn.li.model.Student2"/>
<mapping class="com.dvn.li.model.Teacher2"/>
<mapping class="com.dvn.li.model.TeacherStudent"/>

测试：

SessionFactory sessionFactory = null;
Session session = null;
try {
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
session.beginTransaction();
Student2 s = new Student2();
s.setName("小猪");
Teacher2 t = new Teacher2();
t.setName("小李");
TeacherStudent ts=new TeacherStudent();
ts.setStudent(s);
ts.setTeacher(t);
ts.setNote1("以呀呀！！！");
session.save(s);
session.save(t);
session.save(ts);
session.getTransaction().commit();
} catch (Exception e) {
if (session != null) {
session.getTransaction().rollback();
}
}

测试通过！

小飞鹤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
角色（使用hibernate映射多对多的关系）.zip
07-24
以角色为例，通过Hibernate实现多对多的表关联关系。含源码和脚本。
JPA ManyToMany双向关系
Jc0803kevin的专栏
05-01 1460
N:M（双向）关系维护端 publlic class Student{ public class Teacher{private Set<Teacher> teachers; private Set<Student> students;@ManyToMany(cascade=
SpringData Manytomany 中间表添加额外字段
a1787882124的博客
07-02 2756
SpringData Manytomany 中间表添加额外字段Course跟user是两张多对多关联表添加中间表实体类，表名跟多对多插入的中间表一致说明参数说明 Course跟user是两张多对多关联表 //省略部分不相关代码以及getter跟setter /** * 课程列表 */ @ApiModelProperty(hidden = true) //放弃延时加载，改为立即加载 @ManyToMany(cascade = CascadeType.PERSIST) @JoinTable(name =
Hibernate中多对多的annotation的写法（中间表可以有多个字段）
liuxianbing119的专栏
02-22 1万+
2011-07-04 6:52 一般情况下，多对多的关联关系是需要中间表的； 情况一：如果中间表仅仅是做关联用的，它里面仅有2个外键做联合主键，则使用ManyToMany（不用写中间表的Model，只需要写出两张主表的model即可） 学生表 @Entity @Table(name = "T_STUDENT") @SequenceGenerator(name = "
【Django DRF多对多使用through自定义中间表详解】
qq_24822271的博客
06-23 1138
django manytomany 自定义中间表
manytomany
悲欢离合
04-03 1800
1.Many-to-Many映射(多对多映射关系) 多对多通常是通过建立一张中间表，然后由任一一个多的一方来维护关联关系. 2.一方: @ManyToMany(mappedBy="teachers")　　--->　　表示由另一方来进行维护 3另一方: @ManyToMany　　　--->　ManyToMany指定多对多的关联关系 @JoinTable(name="t_tea...
jpa多对多，中间表有额外查询字段设计，以及使用creteriaquery进行动态查询，使用自定义类进行数据封装返回
qq_45052062的博客
12-15 3484
一.jpa多对多__利用一对多实现(推荐) 尽量不要使用@manyToMany,特别是中间表有冗余字段的时候; 最好是在两个主表中加上@oneToMany,从表中加上@manyToOne来配置,加强jpa对中间表的支持度 !!!注意所有主表中的对应关系都是和映射表建立的 ①表结构 学生表(student) 字段名 字段中文 类型 描述 pk_stu_id 学生id long 主键 stu_name 学生姓名 varchar(10) uk_stu_num 学生学号 具有唯一性
Hibernate中的多表查询及抓取策略
08-31
本文主要介绍了Hibernate中的多表查询及抓取策略，具有很好的参考价值，下面跟着小编一起来看下吧
Many-To-Many_Element.rar_hibernate 多对多
09-21
Hibernate 集合映射:基于HashMap多对多映射 代码,代码出处：http://www.itneng.com/thread-3713-1-1.html
hibernate一对多关联映射学习小结
08-29
主要介绍了hibernate一对多关联映射学习小结,需要的朋友可以参考下
JSP 开发之hibernate的hql查询多对多查询
10-19
主要介绍了JSP 开发之hibernate的hql查询多对多查询的相关资料,希望通过本文能帮助到大家，需要的朋友可以参考下
@ManyToMany中间表附加字段设计
weixin_30384217的博客
07-05 621
在使用@ManyToMany时,若中间表只有相应的外键字段可以直接建立两个对应的Entity 设置ManyToMany @ManyToMany 两个表多对多关联 但若是中间表有自己的附加字段，这需要为中间表建立Entity 具体如下： Teacher <=> Student 中间表 teacher_student 附加字段 id（自增），siteId（站点id方便批删除）...
Django如何在模型的多对多的关系中添加和查看别的字段
qq_41379824的博客
05-22 693
我将以学生与考试做举例，首先学生与考试之间存在多对多的关系，在多对多的关系中不仅包括学生和考试的主键，另外还有学生考试完之后的成绩和学生答题的情况等等，那么我们将如何在多对多关系中添加这些字段呢？以下会详细介绍。 1.在多对多关系中添加新字段 class Student(models.Model): s_id = models.CharField(max_length=10,primary_key=True) #学生学号 s_name = models.CharField(max_
一起来学Java注解（Annotation）
梁初夏的专栏
10-05 6021
本文只是抛砖引玉地讲解了注解的基本概念，注解的作用，几种元注解的功用以及使用方法，并通过一个简单的例子讲解了一下注解的处理，并不全面，文中通过Field讲解了注解的基本Api，但注解还可以修饰类、构造器、方法等，也有相对应的注解处理方法，大家可自行查一下API手册相关内容，大同小异，有不对之处，请批评指正，望共同进步，谢谢！
Hibernate之多对多
TangXS的博客
07-17 157
数据库的多对多（点击查看一对多的关联关系） 数据库中不能直接映射多对多 处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多 注1：数据库多表联接查询，永远就是二个表的联接查询 注2：交叉连接 注3：外连接：left(左)/right(右)/full(左右) 主从表：连接条件不成立时，主表记录永远保留，与null匹配 例如三表：A B AB select * from A,B,AB...
hibernate的多对多
weixin_46705150的博客
07-31 333
1. 数据库的多对多 1.1 数据库中不能直接映射多对多 处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多 注1：数据库多表联接查询 永远就是二个表的联接查询 A B C D t1 C D t2 D t3 注2：交叉连接 注3：外连接：left(左)/right(右)/full(左右) 主从表：连接条件不成立时，主表记录永远保留，与
Hibernate多对多
weixin_43710113的博客
07-17 326
Hibernate多对多 数据库的多对多： 数据库中不能直接映射多对多 处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多 注：数据库多表联接查询，永远就是二个表的联接查询 hibernate的多对多： hibernate可以直接映射多对多关联关系(看作两个一对多) 多对多关系注意事项：一定要定义一个主控方 讲解下一对多的自联： TreeNode.hbm.xml <?xml v...
深入理解Java注解类型(@Annotation)
热门推荐
zejian的博客
05-21 25万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/71860633 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
hibernate怎么多表查询？怎么拼接多个sql的？
最新发布
07-11
对于Hibernate进行多表查询和拼接多个SQL，你可以使用Hibernate的Criteria API或者HQL（Hibernate Query Language）来实现。 1. 多表查询： - 使用Criteria API：你可以使用Criteria API来创建查询条件和关联表。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值