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();
    }
    
    
    
}