Hibernat之关系的处理多对多

第一步：编写两个pojo，比如一个学生表一个课程表这里使用注解。

需要

课程表:

 1 package com.qcf.pox;
 2
 3 import java.util.HashSet;
 4 import java.util.Set;
 5
 6 import javax.persistence.Entity;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.ManyToMany;
11
12 @Entity
13 public class Course {
14     @Id
15     @GeneratedValue(strategy=GenerationType.AUTO)
16     private int id;
17     private String name;
18     @ManyToMany(mappedBy="courses")
19     private Set<Student2> student2s=new HashSet<Student2>();
20     public int getId() {
21         return id;
22     }
23     public void setId(int id) {
24         this.id = id;
25     }
26     public String getName() {
27         return name;
28     }
29     public void setName(String name) {
30         this.name = name;
31     }
32     public Set<Student2> getStudent2s() {
33         return student2s;
34     }
35     public void setStudent2s(Set<Student2> student2s) {
36         this.student2s = student2s;
37     }
38     public Course(int id, String name, Set<Student2> student2s) {
39         super();
40         this.id = id;
41         this.name = name;
42         this.student2s = student2s;
43     }
44     public Course() {
45         super();
46     }
47
48 }

View Code

学生表：

 1 package com.qcf.pox;
 2
 3 import java.util.HashSet;
 4 import java.util.Set;
 5
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Entity;
 8 import javax.persistence.GeneratedValue;
 9 import javax.persistence.GenerationType;
10 import javax.persistence.Id;
11 import javax.persistence.ManyToMany;
12
13 @Entity
14 public class Student2 {
15     @Id
16     @GeneratedValue(strategy=GenerationType.AUTO)
17     private int id;
18     private String name;
19     @ManyToMany(cascade=CascadeType.ALL)
20     private Set<Course> courses=new HashSet<Course>();
21     public int getId() {
22         return id;
23     }
24     public void setId(int id) {
25         this.id = id;
26     }
27     public String getName() {
28         return name;
29     }
30     public void setName(String name) {
31         this.name = name;
32     }
33     public Set<Course> getCourses() {
34         return courses;
35     }
36     public void addCourses(Course courses) {
37         this.courses.add(courses);
38     }
39     public Student2(int id, String name, Set<Course> courses) {
40         super();
41         this.id = id;
42         this.name = name;
43         this.courses = courses;
44     }
45     public Student2() {
46         super();
47     }
48
49 }

View Code

第二步：在hibernate.cfg.xml文件中引入这两个po类

1         <mapping class="com.qcf.pox.Student2"/>
2         <mapping class="com.qcf.pox.Course"/>

View Code

第三步：编写测试代码

 1 package com.qcf.test;
 2
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.AnnotationConfiguration;
 7 import org.hibernate.cfg.Configuration;
 8
 9 import com.qcf.pox.Course;
10 import com.qcf.pox.Student2;
11
12 public class TestManyToMany {
13     public static void main(String[] args) {
14         Configuration configuration=new AnnotationConfiguration().configure();
15         SessionFactory factory=configuration.buildSessionFactory();
16         Session session=factory.openSession();
17         Transaction transaction=session.beginTransaction();
18
19         //创建两个课程
20         Course course=new Course();
21         course.setName("java");
22         Course course2=new Course();
23         course2.setName("C#");
24
25         //创建两个学生
26         Student2 student=new Student2();
27         student.setName("zhangsan");
28         Student2 student2=new Student2();
29         student2.setName("lisi");
30
31         student.addCourses(course);
32         student.addCourses(course2);
33
34         student2.addCourses(course);
35         student2.addCourses(course2);
36
37         session.save(student);
38         session.save(student2);
39
40         transaction.commit();
41         session.close();
42
43     }
44
45 }

View Code

执行成功后的结果：

转载于:https://www.cnblogs.com/quchengfeng/p/4111344.html

Hibernat之关系的处理多对多相关推荐

Hibernate的关系映射——Many-To-Many(多对多)
多对多:多对多的关系至少需要三张表,两张关系表,一张中间表,用来保存两个表之间的关系. 用一个例子来表明多对多的关系:用户.角色以及用户角色. 实际应用中:一个用户可能会有多个角色,而一个角色也会有多 ...
sql语句之多表关系一对多多对多
多表的关系介绍在实际的开发过程中,项目一定是有多张表的,且这些表之间是都有关系的表与表之间的关系分类:一对一一对多多对多一对一:A表的一行对应B表的一行,反之也成立,此时,两张表可以合并成一 ...
Hibernate，关系映射的多对一单向关联、多对一双向关联、一对一主键关联、一对一外键关联、多对多关系关联...
2018-11-10 22:27:02开始写下图内容ORM.Hibernate介绍.hibername.cfg.xml结构: 下图内容hibernate映射文件结构介绍下图内容hibernate ...
SQLAlchemy_定义(一对一/一对多/多对多)关系
SQLAlchemy_定义(一对一/一对多/多对多)关系目录 Basic Relationship Patterns One To Many One To One Many To Many Basi ...
【Hibernate】Hibernate实体关系映射——单边的多对一关系
单边的多对一关系单边的多对一关系与单边的一对多关系刚好相反,多方有一方的引用,一方没有多方的引用,但是他们的数据表间的关系是一样的.例如:论文与论文类别: 具体实现如下: Type实体类的java注 ...
mysql一对多如何设计_数据库在一对一、一对多、多对多怎么设计表关系
1.一对一可以两个实体设计在一个数据库中l例如设计一个夫妻表,里面放丈夫和妻子 2.一对多可以建两张表,将一这一方的主键作为多那一方的外键,例如一个学生表可以加一个字段指向班级(班级与学生一对多的关系 ...
MySQL----表的一对多关系和多对多关系
MySQL----表的一对多关系和多对多关系 1.一对多关系 1.1名词解释: 一对多关系:通过主键外关系,形成一对多关系. 一表:又称之为主表,主表需要提供主键. 多表:又称之为从表,从表需提供外键 ...
多对多关系的多表关联查询
1.什么是多对多关系多对多关系(百度):多对多关系是关系数据库中两个表之间的一种关系, 该关系中第一个表中的一个行可以与第二个表中的一个或多个行相关.第二个表中的一个行也可以与第一个表中的一个或多个 ...
如何使用PowerDesigner软件进行数据库设计（多对多关系）
如何使用PowerDesigner软件进行数据库设计(多对多关系) 1 多对多关系示例 2 创建CDM 3 建立实体之间的联系 4 检查CDM 5 将CDM转换成PDM 6 由PDM生成sql文件 1 ...

Hibernat之关系的处理多对多

Hibernat之关系的处理多对多相关推荐

最新文章

热门文章