hibernate 2 多对多映射

一、实体类

1、Classes.java

package cn.gs.wwg.entity;

import java.util.Set;

public class Classes {
    private int cid;
    private String cname;
    private String cdescription;
    private Set<Student> students;
    public int getCid() {
        return cid;
    }
    public void setCid(int cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public String getCdescription() {
        return cdescription;
    }
    public void setCdescription(String cdescription) {
        this.cdescription = cdescription;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
    
}

2、Student.java

package cn.gs.wwg.entity;

import java.io.Serializable;
import java.util.Set;

public class Student implements Serializable{
    private int sid;
    private String sname;
    private String sdescription;
    private Set<Classes> classes;
    

    public Set<Classes> getClasses() {
        return classes;
    }
    public void setClasses(Set<Classes> classes) {
        this.classes = classes;
    }
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public String getSdescription() {
        return sdescription;
    }
    public void setSdescription(String sdescription) {
        this.sdescription = sdescription;
    }
    
}

二：配置映射信息,建立表与类之间关系

1、Classes.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:持久化类全名
        table: 表名 可以不写 默认和实体类名一致
     -->
    <class name="cn.gs.wwg.entity.Classes" >
        <!-- 
            标示属性 和数据库中主键对应
         -->
        <id name="cid" column="cid" type="java.lang.Integer">
            <!-- 主键产生器 -->
            <generator class="assigned">

            </generator>
        </id>
        <property name="cname" column="cname" type="java.lang.String"></property>
        <property name="cdescription" column="cdescription" type="java.lang.String"></property>
        <!-- 
            cascade="save-update"
            当保存班级的时候对学生进行什么样的操作
         -->
        <set name="students" table="student_classes" cascade="all">
            <!-- key用来描述外键
                set元素对应了classes类中的集合
                通过key是通过外键的形式将两张表建立联系
                通过one-to-many让两个类建立关联
             -->
            <key>
                <column name="cid"></column>
            </key>
            <many-to-many class="cn.gs.wwg.entity.Student" column="sid"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

2、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:持久化类全名
        table: 表名 可以不写 默认和实体类名一致
     -->
    <class name="cn.gs.wwg.entity.Student" >
        <!-- 
            标示属性 和数据库中主键对应
         -->
        <id name="sid" column="sid" type="java.lang.Integer">
            <!-- 主键产生器 -->
            <generator class="assigned">

            </generator>
        </id>
        <property name="sname" column="sname" type="java.lang.String"></property>
        <property name="sdescription" column="sdescription" type="java.lang.String"></property>
           <!-- 
               多对一 column 描述外键
            -->
           <set name="classes" table="student_classes" cascade="all">
            <!-- key用来描述外键
                set元素对应了classes类中的集合
                通过key是通过外键的形式将两张表建立联系
                通过one-to-many让两个类建立关联
             -->
            <key>
                <column name="sid"></column>
            </key>
            <many-to-many class="cn.gs.wwg.entity.Classes" column="cid"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

三、编写配置文件，连接数据库，引入映射信息文件

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    
<hibernate-configuration>
    <!-- 一个session-factory只能链接一个数据库  -->
    <session-factory>
        <!-- 
        进行数据库连接
            driver:驱动
            url:地址
            username:数据库连接用户名
            password:数据库连接密码
            数据库方言
                  不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
              sql99标准: DDL 定义语言  库表的增删改查
                      DCL 控制语言  事务 权限
                      DML 操纵语言  增删改查
             注意: MYSQL在选择方言时,请选择最短的方言.            
         -->
         <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
         <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
         <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
         <property name="connection.username">liuyang</property>
         <property name="connection.password">orcl</property>
         <!-- 
             自动建表  
               auto schema export  自动导出表结构. 自动建表
               hibernate.hbm2ddl.auto create      自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
               hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
               hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
               hibernate.hbm2ddl.auto validate    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
         -->
<!--          <property name="hbm2ddl.auto">update</property> -->
         <property name="hbm2ddl.auto">update</property>
         
         <!-- 将hibernate生成的sql语句打印到控制台 -->
         <property name="show_sql">true</property>    
         <!-- 添加映射文件 -->        
<!--          <mapping resource="cn/gs/ly/entity/Person.hbm.xml"></mapping>      -->
<!--          <mapping resource="cn/gs/ly/school/entity/Student.hbm.xml"></mapping>          -->
<!--          <mapping resource="cn/gs/ly/school/entity/Classes.hbm.xml"></mapping>     -->
         <mapping resource="cn/gs/wwg/entity/Classes.hbm.xml"></mapping>    
         <mapping resource="cn/gs/wwg/entity/Student.hbm.xml"></mapping> 
    </session-factory>
</hibernate-configuration>

四、测试类

ManyToManyTest.java

package cn.gs.wwg.entity.test;

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

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

import cn.gs.wwg.entity.Classes;
import cn.gs.wwg.entity.Student;

public class ManyToManyTest {
    
    SessionFactory factory =null;
    Session se = null;
    Transaction tr = null;
    
    @Before
    public void beforeStart(){
        Configuration con = new Configuration();
        con.configure();
        factory = con.buildSessionFactory();
        se = factory.openSession();
        tr = se.beginTransaction();
    }
    @After
    public void afterClose(){
        tr.commit();
        se.close();
    }
    
    //3.新建一个班级的同时新建一个学生
    @Test
    public void testSaveStudent_Cascade_classes_Save(){
        
        Student student = new Student();
        student.setSid(1);
        student.setSname("小明");
        student.setSdescription("调皮捣蛋");
        
        Classes classes = new Classes();
        classes.setCid(1);
        classes.setCname("gs01");
        classes.setCdescription("有上升空间");
        
//        Set<Classes> cla = new HashSet<Classes>();
//        cla.add(classes);
//        student.setClasses(cla);
        Set<Student> stu = new HashSet<Student>();//实例化一个Set集合存放学生
        stu.add(student); //把学生添加到集合中
        classes.setStudents(stu);
        se.save(classes);

    }
    
    // 4.已经存在一个班级，新建一个学生 建立联系  inverse (班级)
    @Test
    public void testUpdateclasses_Cascade_Student_Save_R(){
        Classes classes = (Classes)se.get(Classes.class, 1);
        Student student = new Student();
        student.setSid(2);
        student.setSname("萌萌");
        student.setSdescription("萌男人");        
        classes.getStudents().add(student);
        //se.save(student); 

    }
    
    // 4.已经存在一个班级，新建一个学生 建立联系  inverse (学生)
    @Test
    public void testSaveStudent_R(){
        Classes classes = (Classes)se.get(Classes.class, 1);
        Student student = new Student();
        student.setSid(3);
        student.setSname("神秘人");
        student.setSdescription("未知");
        Set<Classes> cla = new HashSet<Classes>();
        cla.add(classes);
        student.setClasses(cla);
        se.save(student);

    }
    
    //5.已经存在一个学生，新建一个班级 
    @Test
    public void testSaveStudent_CreateClass(){
        Student student = (Student)se.get(Student.class, 4);
        Classes classes = new Classes();
        classes.setCid(2);
        classes.setCname("gs02");
        classes.setCdescription("一群学霸");
        student.getClasses().add(classes);
    }
    
    //6.把一个学生从一个班级转到另一个班级。
    @Test
    public void testTransform(){        
        Student student = (Student) se.get(Student.class, 1);//学生1从1班转到2班
        Classes classes1 = (Classes)se.get(Classes.class, 1);
        Classes classes2 = (Classes)se.get(Classes.class, 2);
        student.getClasses().remove(classes1);
        student.getClasses().add(classes2);
    }
    
    //8.解除一个班级和一些学生的关系
    @Test
    public void test_Some(){
        Student student = (Student)se.get(Student.class, 1);
        Student student2 = (Student)se.get(Student.class, 2);
        student.setClasses(null);
        student2.setClasses(null);
    }
    
    //11.已经存在了一个班级，也存在许多学生 建立班级与学生的关系。方法一
    @Test
    public void testR_Some(){
        Classes classes = (Classes)se.get(Classes.class,1);
        Student student = (Student)se.get(Student.class, 1);
        Student student2 = (Student)se.get(Student.class, 2);
        student.getClasses().add(classes);
        student2.getClasses().add(classes);
//        classes.getStudents().add(student2);Ч�ʸ�
//        classes.getStudents().add(student);
    }
    
    //11.已经存在了一个班级，也存在许多学生 建立班级与学生的关系。方法二
    @Test
    public void testR_Some_2(){
        Classes classes = (Classes)se.get(Classes.class,1);
        List<Student> studentList = se.createQuery("from Student where sid in(1,2)").list();
        classes.getStudents().addAll(studentList);
    }
    
    //12.已经存在了一些班级，也存在许多学生 建立班级与学生的关系。（每名学生都有多个班级）
    @Test
    public void testR_Some_3(){
        List<Student> studentList = se.createQuery("from Student where sid in(3,4)").list();
        List<Classes> classesList = se.createQuery("from Classes where cid in(1,2)").list();
        for(Student s:studentList){
            s.getClasses().addAll(classesList); //学生3、4都关联两个班级1、2
        }        
    }
    
    //13.删除班级
    @Test
    public void testR_Some_5(){
        Classes classes = (Classes)se.get(Classes.class, 2);
        //classes.setStudents(null);  //解除关系   inverse="true"时需此操作
        se.delete(classes);    
    }
}