Hibernate多对多关系

版权声明:本文为博主原创文章,未经博主允许不得转载

博客地址:http://www.cnblogs.com/caoyc/p/5598932.html

代码:

Teacher.java

 1 package com.proc.pojo;
 2
 3 import java.util.HashSet;
 4 import java.util.Set;
 5
 6 public class Student {
 7     private Integer id;
 8     private String name;
 9     private Set<Teacher> teachers=new HashSet<Teacher>();
10     public Student() {
11     }
12     public Student(String name) {
13         this.name = name;
14     }
15     public Integer getId() {
16         return id;
17     }
18     public void setId(Integer id) {
19         this.id = id;
20     }
21     public String getName() {
22         return name;
23     }
24     public void setName(String name) {
25         this.name = name;
26     }
27     public Set<Teacher> getTeachers() {
28         return teachers;
29     }
30     public void setTeachers(Set<Teacher> teachers) {
31         this.teachers = teachers;
32     }
33     @Override
34     public String toString() {
35         return "Student [id=" + id + ", name=" + name + "]";
36     }
37
38 }

Student.java

 1 package com.proc.pojo;
 2
 3 import java.util.HashSet;
 4 import java.util.Set;
 5
 6 public class Teacher {
 7     private Integer id;
 8     private String name;
 9     private Set<Student> students=new HashSet<Student>();
10     public Teacher() {
11     }
12     public Teacher(String name) {
13         super();
14         this.name = name;
15     }
16     public Integer getId() {
17         return id;
18     }
19     public void setId(Integer id) {
20         this.id = id;
21     }
22     public String getName() {
23         return name;
24     }
25     public void setName(String name) {
26         this.name = name;
27     }
28     public Set<Student> getStudents() {
29         return students;
30     }
31     public void setStudents(Set<Student> students) {
32         this.students = students;
33     }
34     @Override
35     public String toString() {
36         return "Teacher [id=" + id + ", name=" + name + "]";
37     }
38
39 }

Student.hbm.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping package="com.proc.pojo">
 6     <class name="Student" table="t_student">
 7         <id name="id" column="id" type="int">
 8             <generator class="native"></generator>
 9         </id>
10         <property name="name" column="name" type="string" length="20"></property>
11         <set name="teachers" table="t_student_teacher">
12             <key column="studentId"></key>
13             <many-to-many column="teacherId" class="Teacher"></many-to-many>
14         </set>
15     </class>
16 </hibernate-mapping>

Teacher.hbm.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping package="com.proc.pojo">
 6     <class name="Teacher" table="t_teacher">
 7         <id name="id" column="id" type="int">
 8             <generator class="native"></generator>
 9         </id>
10         <property name="name" column="name" type="string" length="20"></property>
11         <set name="students" table="t_student_teacher">
12             <key column="teacherId"></key>
13             <many-to-many column="studentId" class="Student"></many-to-many>
14         </set>
15     </class>
16 </hibernate-mapping>

测试代码:

 1 package com.proc.test;
 2
 3 import java.util.Set;
 4
 5 import org.hibernate.Session;
 6 import org.hibernate.SessionFactory;
 7 import org.hibernate.Transaction;
 8 import org.hibernate.cfg.Configuration;
 9 import org.junit.Test;
10
11
12
13 import com.proc.pojo.Student;
14 import com.proc.pojo.Teacher;
15
16 public class TestManageToManage {
17     private static SessionFactory factory=new Configuration()
18     .configure()
19     .addClass(Student.class)
20     .addClass(Teacher.class)
21     .buildSessionFactory();
22
23
24     @Test
25     public void set(){
26
27     Session session=factory.openSession();
28     Transaction tran=session.beginTransaction();
29
30     Student s1=new Student("张同学");
31     Student s2=new Student("王同学");
32
33     Teacher t1=new Teacher("曹老师");
34     Teacher t2=new Teacher("曾老师");
35
36     s1.getTeachers().add(t1);
37     s2.getTeachers().add(t1);
38     s2.getTeachers().add(t2);
39
40     session.save(s1);
41     session.save(s2);
42     session.save(t1);
43     session.save(t2);
44
45     tran.commit();
46     session.close();
47     }
48
49     @Test
50     public void get(){
51
52     Session session=factory.openSession();
53     Transaction tran=session.beginTransaction();
54
55
56     Teacher t=session.get(Teacher.class, 2);
57     System.out.println(t);
58     Set<Student> set=t.getStudents();
59
60     System.out.println(set);
61     System.out.println("=-------------------------");
62     Student s=session.get(Student.class, 2);
63     System.out.println(s);
64     System.out.println(s.getTeachers());
65
66     tran.commit();
67     session.close();
68     }
69 }
时间: 2024-08-27 09:07:24

Hibernate多对多关系的相关文章

Hibernate多对多关系映射(建表)

下边讲述Hibernate多对多关系映射. 多对多关系的表的结构为: 两个实体表,还包含一个关系表,关系表为复合主键,如果要使用Hibernate多对多关系映射,则关系表必须只包含两个字段,如果生成了Hibernate多对多关系映射,则中间关系表不会生成实体(即没有对应的pojo类,更没有其映射文件). 1.建立表 DROP TABLE user_course ; DROP TABLE user ; DROP TABLE course ; CREATE TABLE user ( userid  

Hibernate多对多关系映射

两张表的多对多关系,在数据库中通常是通过第三张中间表来实现的,第三张中间表放的是两张表各自的主键值,通过主键与主键的对应来体现表直接的关系.比如在权限系统中,一个用户可以拥有多种权限,而一种权限也可以授予多个用户. 在持久化对象设计的时候,角色和用户都分别有一个集合来防止拥有它的用户或角色.角色类的设计: public class RolePO { private int id;  private String name;  private Set employees = new HashSet

hibernate 多对多关系映射

学生 和 课程就是一种多对多的关系映射,那么再hibernate中,对于多对多关系在怎么配置? 和一些注意的事项?简单测试下. 建表 实体 配置文件和映射 测试 1.使用oracle ,建表sql create table students( id number(7) primary key,   name nvarchar2(20),   age number(2) ) create table course( id number(7) primary key,   name nvarchar

hibernate多对多关系配置--增删改查

hibernate多对多关联配置--并实现增删改查 hibernate就不多介绍了,这里就直接上我项目中使用的例子做说明. 数据模型 这是项目中用户和用户组的数据模型er图草稿,具体的model对象字段就以项目中的为主了. model类以及pojo接口,这里pojo接口用不上,大家测试的时候也可以去掉 package com.supre.model; import java.io.Serializable; import java.util.Set; public class User { pr

SSH学习 Hibernate 多对多

Hibernate 多对多关系的处理,是把两个po类(持久化类)分别建表,这两个是要自己写po类和对应的映射文件,两个表的关系另外再建一张表,这个关系表不需要有对应的类,只需在映射文件写必要的标签即可 注明一点:fetch = "join" fetch参数指定了关联对象抓取的方式是select查询还是join查询,select方式时先查询返回要查询的主体对象(列表),再根据关联外键id,每一个对象发一个select查询,获取关联的对象,形成n+1次查询: 而join方式,主体对象和关联

Hibernate多表关系配置——多对多对关系映射

多对多关系:第一个表中的一个行可以与第二个表中的一个或多个行相关.第二个表中的一个行也可以与第一个表中的一个或多个行相关. 一般的设计中,多对多关联映射,需要一个中间表 Hibernate使用many-to-many标签来表示多对多 多对多的关联映射,在实体类中,跟一对多一样,也是用集合来表示的 1.实体 1.1 课程实体 package demo.entity; import java.util.HashSet; import java.util.Set; /** * 课程实体 * @auth

SSH学习四 Hibernate多对一的关系 + 增删改查

多对一关系实现起来不难,只需要在"多"的一方声明外键,声明外键在类的映射文件实现. 下面以老师学生为例,老师是1,学生是多 有一个有趣的地方,在Student类里面,没有声明teacherid这个属性,但是只要在配置文件声明了外键,那么就算类里面没有外键,配置文件的property也没有teacherid 下面是几个关键文件: 1.Student类(包含Student的增删改查) package com.learn.po; import org.hibernate.Session; i

深入浅出Hibernate(二)多对一关系映射

学习Hibernate是为了更方便的操作数据库,在数据库中的关系模型中存在多对一的关系,比如下图所示的员工和部门之间的关系,那么这种关系在Hibernate中如何映射呢?让我用一个小Demo来详细讲解. 建立映射分为以下几步: 1.设计domain对象Department.Employee,代码如下: package cn.itcast.hibernate.domain; public class Department { private int id; private String name;

Hibernate中一对多和多对一关系

1.单向多对一和双向多对一的区别? 只需要从一方获取另一方的数据时 就使用单向关联双方都需要获取对方数据时 就使用双向关系 部门--人员 使用人员时如果只需要获取对应部门信息(user.getdeptarment())不需要 从部门下的人员信息时,就配置成单向 多对一 使用部门时如果只需要获取部门下人员信息(deptartmanet.getusers())不需要 从人员获取部门信息时,就配置成单向 一对多 既要获取部门下人员 deptartmanet.getusers()又要从人员获取部门信息