Hibernate一对多映射

班级表Grade，学生表Student

实现单向一对多

1.在一方的实体类中添加保存many方的集合

2.在一方的配置文件（Grade.hbm.xml）当中添加< one-to-many>配置

实现单向多对一

1.在many方的实体类中添加一方的引用

2.在many方的配置文件中（Student.hbm.xml）添加< many-to-one>配置

常用属性

cascade：设置级联关系

属性值	含义和作用
all	对所有属性进行级联操作
save-update	执行保存和更新操作时进行级联操作
delete	执行删除操作时进行级联操作
none	对所有操作不进行级联操作

inverse：设置由哪一方维护关联关系
例
当在Grade.hbm.xml中的set标签中添加inverse=”true”时，表示由多方（student）进行维护，在StudentText2中使用g.getStudents().add(stu1);方法就无效，需要使用stu1.setGrade(g);方法设置学生所属班级
当在Grade.hbm.xml中的set标签中添加cascade=“save-update”时，表示当执行保存和更新时进行级联操作，在StudentTest2.java中，当使用session.save(g);保存班级对象时，会自动保存班级里学生，不用再另外使用session.save(stu1);保存学生对象
新建一个Java project工程

hibernate.hbm.xml

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123</property>
        <property name="hibernate.connection.url">
            <![CDATA[
                jdbc:mysql://localhost:13306/imooc1?characterEncoding=utf8
            ]]>
        </property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>

        <!-- 指定映射文件的路径 -->
        <mapping resource="com/imooc/entity/Grade.hbm.xml"/>
        <mapping resource="com/imooc/entity/Student.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Grade.java

package com.imooc.entity;

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

public class Grade implements Serializable {

    private int gid;
    private String gname;
    private String gdesc;
    //在一方定义一个多方的集合
    private Set<Student> students=new HashSet<>();
    public Grade() {
        super();
    }
    public Grade(String gname, String gdesc) {
        super();
        this.gname = gname;
        this.gdesc = gdesc;
    }

    public Grade(int gid, String gname, String gdesc) {
        super();
        this.gid = gid;
        this.gname = gname;
        this.gdesc = gdesc;
    }
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public String getGdesc() {
        return gdesc;
    }
    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

Grade.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-6-11 9:26:00 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.imooc.entity.Grade" table="GRADE">
        <id name="gid" type="int">
            <column name="GID" />
            <generator class="increment" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="GNAME" />
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC" />
        </property>
        <!-- 配置单向的一对多关联关系，设置inverse属性为true，由多方进行维护 cascade保存和更新时自动进行级联操作-->
        <set name="students" table="STUDENT" inverse="true" cascade="save-update">
            <key>
                <column name="GID" />
            </key>
            <one-to-many class="com.imooc.entity.Student" />
        </set>
    </class>
</hibernate-mapping>

Student.java

package com.imooc.entity;

import java.io.Serializable;

public class Student implements Serializable {

    private int sid;
    private String sname;
    private String sex;
    //在多方定义一个一方的引用
    private Grade grade;
    public Student() {
        super();
    }
    public Student(String sname, String sex) {
        super();
        this.sname = sname;
        this.sex = sex;
    }
    public Student(int sid, String sname, String sex) {
        super();
        this.sid = sid;
        this.sname = sname;
        this.sex = sex;
    }
    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 getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }

}

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-6-11 9:26:00 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.imooc.entity.Student" table="STUDENT">
        <id name="sid" type="int">
            <column name="SID" />
            <generator class="increment" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>
        <property name="sex" type="java.lang.String">
            <column name="SEX" />
        </property>
        <many-to-one name="grade" class="com.imooc.entity.Grade" column="gid" cascade="all"></many-to-one>
    </class>
</hibernate-mapping>

HibernateUtil.java

package com.imooc.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {

    private static SessionFactory sessionFactory;
    private static Session session;
    static{
        //创建Configuration对象，读取hibernate.cfg.xml,完成初始化
        Configuration config=new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
    public static Session getSession(){
        session=sessionFactory.openSession();
        if(session!=null){
            System.out.println("*********************");
        }
        return session;
    }
    public static void closeSession(Session session){
        if(session!=null){
            session.close();
        }
    }
}

测试类StudentTest.java

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
/**
 * 单向一对多关系(班级---->学生)
 * 建立关联联系后，可以从一个对象导航到另一个对象
 * @author liqiao1314
 *
 */
public class StudentTest {

    //将学生添加到班级
    @Test
    public void add(){
        Grade g=new Grade("java一班", "java软件技术一班");
        Student stu1=new Student("张三", "男");
        Student stu2=new Student("穆女神", "女");
        //如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
        g.getStudents().add(stu1);
        g.getStudents().add(stu2);

        Session session=HibernateUtil.getSession();
        Transaction transaction=session.beginTransaction();
        session.save(g);
        session.save(stu1);
        session.save(stu2);
        transaction.commit();
        HibernateUtil.closeSession(session);
    }
    //查询学生班级
    @Test
    public void findStudentsByGrade(){
        Session session=HibernateUtil.getSession();
        Grade g=(Grade) session.get(Grade.class, 1);
        System.out.println(g.getGname()+","+g.getGdesc());
        Set<Student> students=g.getStudents();
        for (Student stu: students) {
            System.out.println(stu.getSname()+","+stu.getSex());
        }
    }
    @Test
    public void update(){
        Session session=HibernateUtil.getSession();
        Transaction t=session.beginTransaction();
        Grade g=new Grade("java二班", "java软件技术二班");
        Student stu=(Student) session.get(Student.class, 1);
        g.getStudents().add(stu);
        session.save(g);
        t.commit();
        HibernateUtil.closeSession(session);
    }
    @Test
    public void delete(){
        Session session =HibernateUtil.getSession();
        Transaction t=session.beginTransaction();
        Student stu=(Student) session.get(Student.class, 2);
        session.delete(stu);
        t.commit();
        HibernateUtil.closeSession(session);
    }
}

测试类StudentTest2.java

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
/**
 * 单向多对一关系(学生---->班级)
 * 建立关联联系后，可以从一个对象导航到另一个对象
 * @author liqiao1314
 *
 */
public class StudentTest2 {

    @Test
    public void save(){
        Grade g=new Grade("java一班", "java软件技术一班");
        Student stu1=new Student("张三", "男");
        Student stu2=new Student("穆女神", "女");

        g.getStudents().add(stu1);
        g.getStudents().add(stu2);
        //设置关联关系
        stu1.setGrade(g);
        stu2.setGrade(g);

        Session session=HibernateUtil.getSession();
        Transaction transaction=session.beginTransaction();
        session.save(g);
        //session.save(stu1);
        //session.save(stu2);
        transaction.commit();
        HibernateUtil.closeSession(session);
    }

}