Hibernate 多对多关联Demo

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

 //Course .java

 public class Course implements Serializable {
     private long cid;
     private String cname;
     private String cdesc;
     private Set<Student> students;
  //get与set
 }

//Student.java
1 public class Student implements Serializable {
     private Long sid;
     private String sname;
     private String sdesc;
     private Set<Course> courses;
 //get与set

 }

 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.test.test.Course">
         <id name="cid" type="java.lang.Long" length="5">
             <column name="cid"></column>
             <generator class="increment"></generator>
         </id>
         <property name="cname" type="java.lang.String" length="20"></property>
         <property name="cdesc" type="java.lang.String" length="50"></property>
         <!--
             table 指的是多对多的第三张表
          -->
         <set name="students" table="Course_Student" cascade="save-update" inverse="true">
             <key>
                 <column name="cid"></column>
             </key>
             <many-to-many class="cn.test.test.Student" column="sid">
             </many-to-many>
         </set>
     </class>
 </hibernate-mapping>

 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.test.test.Student">
         <id name="sid" type="java.lang.Long" length="5">
             <column name="sid"></column>
             <generator class="increment"></generator>
         </id>
         <property name="sname" type="java.lang.String" length="20"></property>
         <property name="sdesc" type="java.lang.String" length="50"></property>
         <set name="courses" table="Course_Student" cascade="save-update" >
             <key>
                 <column name="sid"></column>
             </key>
             <many-to-many class="cn.test.test.Course" column="cid">
             </many-to-many>
         </set>
     </class>
 </hibernate-mapping>

 package cn.test.test;

 import java.util.HashSet;
 import java.util.Set;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 public class DoTest {
     private static SessionFactory sessionFactory;
     static{
         Configuration configuration=new Configuration();
         configuration.configure();
         sessionFactory=configuration.buildSessionFactory();
     }

     /**
      * 1、保存课程
      * 2、保存学生
      * 3、保存课程的时候同时保存学生
      * 4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
      * 5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
      * 6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
      * 7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
      * 8、已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
      * 9、解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
      * 10、解除该课程和所有的学生之间的关系
      * 11、删除课程
      *      *
      *          *  解除该班级和所有的学生之间的关系
      *          *  删除该班级
      *      *
      *          删除班级的同时删除学生
      * 12、删除学生
      *      同删除班级
      *
      */

     //1、保存课程
     @Test
     public void testSaveCourse(){
         Session session =sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Course course=new Course();
         course.setCname("java基础");
         course.setCdesc("21天精通java基础");
         session.save(course);

         transaction.commit();
         session.close();
     }

     //2、保存学生
     @Test
     public void testSaveStudent(){
         Session session=sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Student student=new Student();
         student.setSname("张三");
         student.setSdesc("张四他哥，就是这么的霸气");
         session.save(student);

         transaction.commit();
         session.close();
     }

     //3、保存课程的时候同时保存学生
     @Test
     public void testSaveCourse_Student(){
         Session session =sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Course course=new Course();
         course.setCname("Net 基础");
         course.setCdesc("学习完java就要学习net");

         Student student=new Student();
         student.setSname("张大全");
         student.setSdesc("编程语言都要学会");
         Set<Student> set=  new HashSet<Student>();
         set.add(student);
         course.setStudents(set);

         session.save(course);

         transaction.commit();
         session.close();
     }

     //4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
     @Test
     public void testSaveStudent_Course(){
         Session session =sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Course course=new Course();
         course.setCname("Net2 基础");
         course.setCdesc("学习完java就要学习net2");
         Set<Course> set=new HashSet<Course>();
         set.add(course);

         Student student=new Student();
         student.setSname("张大全2");
         student.setSdesc("编程语言都要学会2");
         student.setCourses(set);

         session.save(student);

         transaction.commit();
         session.close();
     }

     //5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
     @Test
     public void testSaveCourse_R_Student(){
         Session session=sessionFactory.openSession();
         Transaction transaction= session.beginTransaction();

         Course course=(Course) session.get(Course.class, 1L);

         Student student=new Student();
         student.setSname("fds");
         student.setSdesc("1234567890-=");

         Set<Course> set =new HashSet<Course>();
         set.add(course);

         student.setCourses(set);

         session.save(student);

         transaction.commit();
         session.close();
     }

     //6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
     @Test
     public void testSaveStudent_R_Course(){
         Session session=sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Student student=(Student) session.get(Student.class,13L);

         Course course=new Course();
         course.setCname("C++ 大学教材");
         course.setCdesc("dsajkdsfnsdahfsdjkabdklsatgf");

         student.getCourses().add(course);

         session.save(student);

         transaction.commit();
         session.close();
     }

     //7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
     @Test
     public void testRelease_Rebuild(){
         Session session=sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Student student=(Student) session.get(Student.class, 13L);
         Course course=(Course) session.get(Course.class, 2L);

         Set<Course> courses= student.getCourses();
         for(Course c:courses){
             if(c.getCid()==5){
                 courses.remove(c);
                 break;
             }
         }

         courses.add(course);

         transaction.commit();
         session.close();
     }

     //8、已经存在一个学生，已经存在多个课程，解除该学生和原来多个课程之间的关系，建立该学生和新的多个课程之间的关系
     @Test
     public void testRelaease_All(){
         Session session=sessionFactory.openSession();
         Transaction transaction=session.beginTransaction();

         Student student=(Student) session.get(Student.class, 13L);
         Set<Course> courses=student.getCourses();
         for(Course c:courses){
             if(c.getCid()==1 || c.getCid()==2){
                 courses.remove(c);
                 break;///????不能同时删除两个，只能break，删除一个
             }
         }

         Course c4=(Course) session.get(Course.class, 4L);
         Course c5=(Course) session.get(Course.class, 5L);

         courses.add(c4);
         courses.add(c5);

         transaction.commit();
         session.close();
     }
     //已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
     @Test
     public void testR_All(){
         Session session=sessionFactory.openSession();
         Transaction transaction =session.beginTransaction();

         Student student=(Student) session.get(Student.class, 12L);
         student.setCourses(null);

         transaction.commit();
         session.close();
     }

     //解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
     /*
      * 说明：
      *     *  必须由学生来维护关系
      *     *  已经条件是课程
      *         cid-->course-->set<student>-->遍历每一个student
      *         -->从每一个student中得到所有的课程-->找到要移除的课程-->移除
      *
      */

     @Test
     public void testRemoveAll_Rebuild(){
         Session session= sessionFactory.openSession();
         Transaction transaction= session.beginTransaction();

         Course course=(Course) session.get(Course.class, 4L);//获取该课程
         Set<Student> students=course.getStudents();//获取该课程的学生
         for(Student s:students){
             Set<Course> courses=s.getCourses();//该学生所选取的所有课程
             for(Course c:courses){
                 if(c.getCid()==4){
                     courses.remove(c);
                     break;
                 }
             }
         }

         Student s1=(Student) session.get(Student.class, 9L);
         Student s2=(Student) session.get(Student.class, 10L);
         s1.getCourses().add(course);
         s2.getCourses().add(course);

         transaction.commit();
         session.close();
     }

 }

多对多例子