课程Course和学生Student之间的关系!典型的多对多!多对多需要一张中间表来保存两者之间的关系!
course
cid
cname
cdescription
|
student
sid
sname
sdescription
|
中间表:
student_couse
sid primary key;
cid primary key;
foreign key(cid) references couser(cid);
foreign key(sid) references student(sid);
|
1、类的设计:你中有我,我中有你!
public
class Course {
Long
cid;
String
cname;
String
cdescriprion;
//该课程下的学生
Set<Student>
students;
//get和set方法
}
|
public
class Student {
Long
sid;
String
sname;
String
sdescription;
//学生所修课程
Set<Course>
courses;
//get和set方法
}
|
2.映射文件:
映射文件写好后,应当添加到hibernate.cfg.xml配置文件中!
hibernate生成表是根据配置文件来生成的!
在映射文件中,需要表示清楚两张表以及中间表之间的关系!
Student.hbm.xml:
<?
xml
version= "1.0" encoding ="utf-8"?>
<!
DOCTYPE
hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"
>
<
hibernate-mapping
>
<
class
name="cn.itheima03.hibernate.manytomany.Student" table="student" >
<id name= "sid" type ="java.lang.Long" length= "5" >
<column name= "sid"></column >
<generator class= "increment"></generator >
</id>
<property name= "sname" length ="20"></ property>
<property name= "sdescription" length="50" ></property>
<!--table 用来描述第三张表 -->
<set name= "courses" table ="student_course" >
<key>
<!-- 第三张表的主键 -->
<column name= "sid"></column >
</key>
<!-- cid 第三张表的主键 -->
<many-to-many class="cn.itheima03.hibernate.manytomany.Course" column="cid" ></many-to-many >
</set>
</
class
>
</
hibernate-mapping
>
|
Course.hbm.xml:
<?
xml
version= "1.0" encoding ="utf-8"?>
<!
DOCTYPE
hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"
>
<
hibernate-mapping
>
<
class
name="cn.itheima03.hibernate.manytomany.Course" table="course" >
<id name= "cid" type ="java.lang.Long" length= "5" >
<column name= "cid"></column >
<generator class= "increment"></generator >
</id>
<property name= "cname" length ="20"></ property>
<property name= "cdescriprion" length="50" ></property>
<!--第三张表应该为同一张表 -->
<set name= "students" cascade ="save-update" inverse="false" table="student_course">
<key>
<column name= "cid"></column >
</key>
<!-- 用来建立中间的关系表 -->
<many-to-many class="cn.itheima03.hibernate.manytomany.Student" column="sid" ></many-to-many>
</set>
</
class
>
</
hibernate-mapping
>
|
将这两个映射文件添加到配置文件中:
生成表的结构:
3.DAO操作
public
class ManyToManyTest extends HibernateUtils {
/**
* 1、增加一门课程
* 2、增加一个学生
* 3、增加一门课程同时级联增加一个学生
* 4、存在一门课程,新建一个学生,把该学生加入到该课程
* 5、存在一个学生,新建一个课程,把该学生加入到该课程
* 以课程出发维护关系效率比较高
* 6、把一个学生从一门课程转移到另一门课程
* 7、把一门课程的所有的学生全部移除
* 8、解除一门课程和一些学生之间的关系
* 9、删除课程
* 1、删除课程的同时,删除学生
* 2、先解除关系,再删除课程
* 10、删除学生
* 同上
* 11、新建一个课程 ,已经存在多个学生,这些学生同时修2门课程,解除该学生和这两门课程之间的关系,建立
* 这些学生和新的课程之间的关系
*
@author Think
*
*/
/**
* 1。增加课程
*/
@Test
public
void test1(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Course course=
new Course();
course.setCname(
"java基础");
course.setCdescriprion(
"基础要学好,不然后果很严重" );
session.save(course);
transaction.commit();
session.close();
}
/**
* 2。增加学生
*/
@Test
public
void test2(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"张三");
student.setSdescription(
"张三要努力" );
session.save(student);
transaction.commit();
session.close();
}
/**
* 3。增加课程的同时,级联增加一名学生
* course.hbm.xml
* <set name="students" cascade="save-update" inverse="false" table="student_course">
* 结果:三张表的数据都发生了变化
*/
@Test
public
void test3(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"张三2");
student.setSdescription(
"张三要努力" );
Course course=
new Course();
course.setCname(
"java基础2");
course.setCdescriprion(
"基础要学好,不然后果很严重" );
//将学生添加到集合中
Set<Student> students=
new HashSet<Student>();
students.add(student);
course.setStudents(students);
session.save(course);
transaction.commit();
session.close();
}
/**
* 3
-2。增加学生的同时,级联增加一名课程
* student.hbm.xml
* <set name="courses" cascade="save-update" table="student_course" >
* 三张表数据都发生了变化!
*/
@Test
public
void test3_2(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"张三3");
student.setSdescription(
"张三要努力" );
Course course=
new Course();
course.setCname(
"java基础3");
course.setCdescriprion(
"基础要学好,不然后果很严重" );
//将课程添加到集合中;
Set<Course> courses=
new HashSet<Course>();
courses.add(course);
student.setCourses(courses);
session.save(student);
transaction.commit();
session.close();
}
/**
* 3—3。增加课程的同时,级联增加一名学生,inverse为true:表示不维护关系!
* course.hbm.xml
* <set name="students" cascade="save-update" inverse="true" table="student_course">
* 结果:只有student、course这两张表发生了变化;
* stutdent_course这张关系表没有发生变化!验证了inverse维护关系这一功能!
*/
@Test
public
void test3_3(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"张三4");
student.setSdescription(
"张三要努力" );
Course course=
new Course();
course.setCname(
"java基础4");
course.setCdescriprion(
"基础要学好,不然后果很严重" );
//将学生添加到集合中
Set<Student> students=
new HashSet<Student>();
students.add(student);
course.setStudents(students);
session.save(course);
transaction.commit();
session.close();
}
/**
* 4、存在一门课程,新建一个学生,把该学生加入到该课程
* 从课程角度出发!
*/
@Test
public
void test4(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"李四");
student.setSdescription(
"李四也要努力" );
Course course=(Course) session.get(Course.
class, 1L);
//将学生添加到集合中,需要发出查询语句
course.getStudents().add(student);
transaction.commit();
session.close();
}
/**
* 4
-2、存在一门课程,新建一个学生,把该学生加入到该课程
* 从学生角度出发!
* 对比上述例子,可以发现从学生端出发效率要高一些!
*
*/
@Test
public
void test4_2(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Student student=
new Student();
student.setSname(
"李四2");
student.setSdescription(
"李四也要努力" );
Course course=(Course) session.get(Course.
class, 2L);
//将课程添加到集合中
Set<Course> courses=
new HashSet<Course>();
courses.add(course);
student.setCourses(courses);
session.save(student);
transaction.commit();
session.close();
}
/**
* 5、存在一个学生,新建一个课程,把该学生加入到该课程
* 从课程出发,效率较高
*/
@Test
public
void test5(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Course course=
new Course();
course.setCname(
"java web");
course.setCdescriprion(
"学好java web 走上人生巅峰" );
Student student=(Student) session.get(Student.
class
, 1L);
Set<Student> students=
new HashSet<Student>();
students.add(student);
course.setStudents(students);
session.save(course);
transaction.commit();
session.close();
}
/**
* 6、把一个学生从一门课程转移到另一门课程
* 更新关系!先删除关系,再添加关系!
*/
@Test
public
void test6(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
//三号学生从三号课程移动到一号课程
Student student=(Student) session.get(Student.
class
, 3L);
Course course1=(Course) session.get(Course.
class
, 3L);
Course course2=(Course) session.get(Course.
class
, 1L);
//先删除,后添加
student.getCourses().remove(course1);
student.getCourses().add(course2);
transaction.commit();
session.close();
}
/**
* 7、把一门课程的所有的学生全部移除
* 集合设为null
*/
@Test
public
void test7(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Course course=(Course) session.get(Course.
class, 2L);
course.setStudents(
null);
transaction.commit();
session.close();
}
/**
* 8、解除一门课程和一些学生之间的关系
* 从学生角度出发和从课程角度出发
*/
@Test
public
void test8(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Course course=(Course) session.get(Course.
class, 1L);
Student student1=(Student) session.get(Student.
class
, 6L);
Student student2=(Student) session.get(Student.
class
, 8L);
//从学生角度出发:解除学生和课程的关系
/*student1.getCourses().remove(course);
student2.getCourses().remove(course);*/
//从课程角度出发:从集合中移除!,效率较高
course.getStudents().remove(student1);
course.getStudents().remove(student2);
transaction.commit();
session.close();
}
/**
* 9、删除课程
* 1、先解除关系,再删除课程
* 2、删除课程的同时,删除学生
*/
@Test
public
void test9(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
Course course=(Course) session.get(Course.
class, 4L);
//1.解除关系,删除课程;
/*course.setStudents(null);
session.delete(course);*/
//2.删除课程的同时,删除学生!
Set<Student> students = course.getStudents();
for (Student student : students) {
session.delete(student);
}
session.delete(course);
transaction.commit();
session.close();
}
/**
* 11、新建一个课程 ,已经存在多个学生,这些学生同时修2门课程,解除该学生和这两门课程之间的关系,建立
* 这些学生和新的课程之间的关系
*/
@Test
public
void test11(){
Session session =
sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
//新建一门课程
Course course=
new Course();
course.setCname(
"三大框架" );
course.setCdescriprion(
"三大框架很重要" );
//1、6课程
Course course1=(Course) session.get(Course.
class
, 1L);
Course course6=(Course) session.get(Course.
class
, 6L);
//学生集合转移
course.setStudents(course1.getStudents());
//解除学生和这两门的关系
course1.setStudents(
null);
course6.setStudents(
null);
session.save(course);
transaction.commit();
session.close();
}
}
|