Hibernate 多对多关联Demo

以学生[Student ]与课程[Course ]之间的关系为例：

1 //Course .java
2
3 public class Course implements Serializable {
4     private long cid;
5     private String cname;
6     private String cdesc;
7     private Set<Student> students;
8  //get与set
9 }
//Student.java1 public class Student implements Serializable {
2     private Long sid;
3     private String sname;
4     private String sdesc;
5     private Set<Course> courses;
6 //get与set
7
8 }

 Course.hbm.xml

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <hibernate-mapping>
 5     <class name="cn.test.test.Course">
 6         <id name="cid" type="java.lang.Long" length="5">
 7             <column name="cid"></column>
 8             <generator class="increment"></generator>
 9         </id>
10         <property name="cname" type="java.lang.String" length="20"></property>
11         <property name="cdesc" type="java.lang.String" length="50"></property>
12         <!--
13             table 指的是多对多的第三张表
14          -->
15         <set name="students" table="Course_Student" cascade="save-update" inverse="true">
16             <key>
17                 <column name="cid"></column>
18             </key>
19             <many-to-many class="cn.test.test.Student" column="sid">
20             </many-to-many>
21         </set>
22     </class>
23 </hibernate-mapping>

 Student.hbm.xml

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <hibernate-mapping>
 5     <class name="cn.test.test.Student">
 6         <id name="sid" type="java.lang.Long" length="5">
 7             <column name="sid"></column>
 8             <generator class="increment"></generator>
 9         </id>
10         <property name="sname" type="java.lang.String" length="20"></property>
11         <property name="sdesc" type="java.lang.String" length="50"></property>
12         <set name="courses" table="Course_Student" cascade="save-update" >
13             <key>
14                 <column name="sid"></column>
15             </key>
16             <many-to-many class="cn.test.test.Course" column="cid">
17             </many-to-many>
18         </set>
19     </class>
20 </hibernate-mapping>

  1 package cn.test.test;
  2
  3 import java.util.HashSet;
  4 import java.util.Set;
  5
  6 import org.hibernate.Session;
  7 import org.hibernate.SessionFactory;
  8 import org.hibernate.Transaction;
  9 import org.hibernate.cfg.Configuration;
 10 import org.junit.Test;
 11
 12 public class DoTest {
 13     private static SessionFactory sessionFactory;
 14     static{
 15         Configuration configuration=new Configuration();
 16         configuration.configure();
 17         sessionFactory=configuration.buildSessionFactory();
 18     }
 19
 20     /**
 21      * 1、保存课程
 22      * 2、保存学生
 23      * 3、保存课程的时候同时保存学生
 24      * 4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
 25      * 5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
 26      * 6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
 27      * 7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
 28      * 8、已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
 29      * 9、解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
 30      * 10、解除该课程和所有的学生之间的关系
 31      * 11、删除课程
 32      *      *
 33      *          *  解除该班级和所有的学生之间的关系
 34      *          *  删除该班级
 35      *      *
 36      *          删除班级的同时删除学生
 37      * 12、删除学生
 38      *      同删除班级
 39      *
 40      */
 41
 42
 43     //1、保存课程
 44     @Test
 45     public void testSaveCourse(){
 46         Session session =sessionFactory.openSession();
 47         Transaction transaction=session.beginTransaction();
 48
 49         Course course=new Course();
 50         course.setCname("java基础");
 51         course.setCdesc("21天精通java基础");
 52         session.save(course);
 53
 54         transaction.commit();
 55         session.close();
 56     }
 57
 58     //2、保存学生
 59     @Test
 60     public void testSaveStudent(){
 61         Session session=sessionFactory.openSession();
 62         Transaction transaction=session.beginTransaction();
 63
 64         Student student=new Student();
 65         student.setSname("张三");
 66         student.setSdesc("张四他哥，就是这么的霸气");
 67         session.save(student);
 68
 69         transaction.commit();
 70         session.close();
 71     }
 72
 73     //3、保存课程的时候同时保存学生
 74     @Test
 75     public void testSaveCourse_Student(){
 76         Session session =sessionFactory.openSession();
 77         Transaction transaction=session.beginTransaction();
 78
 79         Course course=new Course();
 80         course.setCname("Net 基础");
 81         course.setCdesc("学习完java就要学习net");
 82
 83         Student student=new Student();
 84         student.setSname("张大全");
 85         student.setSdesc("编程语言都要学会");
 86         Set<Student> set=  new HashSet<Student>();
 87         set.add(student);
 88         course.setStudents(set);
 89
 90         session.save(course);
 91
 92         transaction.commit();
 93         session.close();
 94     }
 95
 96     //4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
 97     @Test
 98     public void testSaveStudent_Course(){
 99         Session session =sessionFactory.openSession();
100         Transaction transaction=session.beginTransaction();
101
102         Course course=new Course();
103         course.setCname("Net2 基础");
104         course.setCdesc("学习完java就要学习net2");
105         Set<Course> set=new HashSet<Course>();
106         set.add(course);
107
108         Student student=new Student();
109         student.setSname("张大全2");
110         student.setSdesc("编程语言都要学会2");
111         student.setCourses(set);
112
113         session.save(student);
114
115         transaction.commit();
116         session.close();
117     }
118
119     //5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
120     @Test
121     public void testSaveCourse_R_Student(){
122         Session session=sessionFactory.openSession();
123         Transaction transaction= session.beginTransaction();
124
125         Course course=(Course) session.get(Course.class, 1L);
126
127         Student student=new Student();
128         student.setSname("fds");
129         student.setSdesc("1234567890-=");
130
131         Set<Course> set =new HashSet<Course>();
132         set.add(course);
133
134
135         student.setCourses(set);
136
137         session.save(student);
138
139         transaction.commit();
140         session.close();
141     }
142
143     //6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
144     @Test
145     public void testSaveStudent_R_Course(){
146         Session session=sessionFactory.openSession();
147         Transaction transaction=session.beginTransaction();
148
149         Student student=(Student) session.get(Student.class,13L);
150
151         Course course=new Course();
152         course.setCname("C++ 大学教材");
153         course.setCdesc("dsajkdsfnsdahfsdjkabdklsatgf");
154
155         student.getCourses().add(course);
156
157         session.save(student);
158
159         transaction.commit();
160         session.close();
161     }
162
163     //7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
164     @Test
165     public void testRelease_Rebuild(){
166         Session session=sessionFactory.openSession();
167         Transaction transaction=session.beginTransaction();
168
169         Student student=(Student) session.get(Student.class, 13L);
170         Course course=(Course) session.get(Course.class, 2L);
171
172         Set<Course> courses= student.getCourses();
173         for(Course c:courses){
174             if(c.getCid()==5){
175                 courses.remove(c);
176                 break;
177             }
178         }
179
180         courses.add(course);
181
182         transaction.commit();
183         session.close();
184     }
185
186     //8、已经存在一个学生，已经存在多个课程，解除该学生和原来多个课程之间的关系，建立该学生和新的多个课程之间的关系
187     @Test
188     public void testRelaease_All(){
189         Session session=sessionFactory.openSession();
190         Transaction transaction=session.beginTransaction();
191
192         Student student=(Student) session.get(Student.class, 13L);
193         Set<Course> courses=student.getCourses();
194         for(Course c:courses){
195             if(c.getCid()==1 || c.getCid()==2){
196                 courses.remove(c);
197                 break;///????不能同时删除两个，只能break，删除一个
198             }
199         }
200
201         Course c4=(Course) session.get(Course.class, 4L);
202         Course c5=(Course) session.get(Course.class, 5L);
203
204         courses.add(c4);
205         courses.add(c5);
206
207         transaction.commit();
208         session.close();
209     }
210     //已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
211     @Test
212     public void testR_All(){
213         Session session=sessionFactory.openSession();
214         Transaction transaction =session.beginTransaction();
215
216         Student student=(Student) session.get(Student.class, 12L);
217         student.setCourses(null);
218
219         transaction.commit();
220         session.close();
221     }
222
223     //解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
224     /*
225      * 说明：
226      *     *  必须由学生来维护关系
227      *     *  已经条件是课程
228      *         cid-->course-->set<student>-->遍历每一个student
229      *         -->从每一个student中得到所有的课程-->找到要移除的课程-->移除
230      *
231      */
232
233     @Test
234     public void testRemoveAll_Rebuild(){
235         Session session= sessionFactory.openSession();
236         Transaction transaction= session.beginTransaction();
237
238         Course course=(Course) session.get(Course.class, 4L);//获取该课程
239         Set<Student> students=course.getStudents();//获取该课程的学生
240         for(Student s:students){
241             Set<Course> courses=s.getCourses();//该学生所选取的所有课程
242             for(Course c:courses){
243                 if(c.getCid()==4){
244                     courses.remove(c);
245                     break;
246                 }
247             }
248         }
249
250         Student s1=(Student) session.get(Student.class, 9L);
251         Student s2=(Student) session.get(Student.class, 10L);
252         s1.getCourses().add(course);
253         s2.getCourses().add(course);
254
255         transaction.commit();
256         session.close();
257     }
258
259
260
261 }

多对多例子

时间： 2024-10-13 12:40:40

Hibernate 多对多关联Demo的相关文章

hibernate多对一关联映射

hibernate多对一关联映射: 实体类 (POJO) public class Student{ private int stuId; private String stuNum; private String stuName; private ClassRoom cr; } public class ClassRoom{ private int claId; private String claName; } 映射文件 <class name=" Student" tabl

atitit.atitit.hb many2one relate hibernate 多对一关联配置..

atitit.atitit.hb many2one relate hibernate 多对一关联配置.. 1. 多对一单向 @ManyToOne 1 1. 其中@JoinColumn 注解 2 2. @targetEntity注解 2 2. 生成的sql LEFT OUTER 2 3. 多对一也可以通过关联表的方式来映射,通过 @JoinTable 注解可 2 4. 另外一个属性也关联到table column(recomn?? ) 3 5. 参考 3 1. 多对一单向 @ManyToOne (

05.Hibernate多对多关联

前言:本文讲解使用Hibernate映射多对多关联关系,并使用多种方式映射多对多关联. 1.数据库表的多对多关系 本文根据学生信息表(tb_student)和教师信息表(tb_teacher)来说明多对多映射关系,一个学生有多个老师,一个老师也有多个学生,其数据库模型图如下: 根据以上图,对应的建表语句如下: CREATE TABLE tb_student ( id bigint NOT NULL auto_increment COMMENT 'ID', no varchar(10) NOT N

hibernate多对多关联

多对多表的搭建 java类中 多对多 1.关系操作 1.多对多,谁操作效率都一样 2.解除关系 把第三张表的一行数据删除掉 3.建立关系 把第三张表的数据增加一行记录 4.变更关系 先删除后增加 2.级联操作 都是对象针对集合的操作 例子 工具类 public class HibernateUtils {     public static SessionFactory sessionFactory;     public static String url;     @Before     p

hibernate多对一关联映射两种形式的理解

关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 多对一单向和多对一双向关联: 单向:多对一单向是只用维护多的一方,例如一家厂商(Factory)可以生产多种产品(Product),只用在Product实体类和配置文件中配置即可.在Product实体属性类中,需要有Factory属性,而不再需要外键这个属性,因为关联外键的配置在配置文件中many-to-one. 双向:多对一双向关联需要双方都维护对方,例如班级(Class)和学生(Student)之间的关系,需要在Class实体类和

Hibernate 多对一关联查询

一.单向多对一和双向多对一的区别 如果只需要从一方获取另一方数据,就用单向多对一:如果需要从双方都获取对方数据,就用双向多对一. 如果有两个对象,一个为User对象,一个为Department对象,一个用户只能属于一个部门,而一个部门可以包含多个用户.这样就是多对一关系.如下图 假设:我们需要通过用户找到所对应的部门,不需要通过部门查询该部门有哪些用户,就采用单向多对一关系 如果:我们不仅需要通过用户获取所对应的部门,还需要通过部门对象获取该部门下的用户,那么就采用双向多对一 二.单向多对一关系

hibernate多对多关联配置文件写法

CmsUserEntry Set<CmsRoleEntry> roles=new CmsRoleEntry(); public void getroles(){ Return roles; } Public void setroles(Set<CmsRoleEntry> cmsRoleEntrys){ thisNaNsRoleEntrys=cmsRoleEntrys; } CmsRoleEntry Set<CmsUserEntry> users=new CmsUserE

Hibernate 多对多关联查询条件使用

from Brand as b inner join fetch b.styles as s where s.styleId=?

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

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