Hibernate利用关联关系操纵对象

时间 2019-11-18

原文原文链接

Hibernate利用关联关系操纵对象

数据对象之间关联关系有一对1、一对多及多对多关联关系。在数据库操做中，数据对象之间的关联关系使用JDBC处理很困难。本节讲解如何在Hibernate中处理这些对象之间的关联关系。本节使用到4个类，它们分别是Student（学生）、Card（学生证）、Group（班级）和Course（课程），它们之间的关联关系如图1-1所示。这些实体存在级联(cascade)问题。例如，当删除一个班级的信息时，还要删除该班的全部学生的基本信息。若是直接使用JDBC执行这种级联操做，会很是烦琐。Hibernate经过把实体对象之间关联关系及级联关系在映射文件中声明，比较简便地解决了这类级联操做问题。 java

图1-1 对象关联图程序员

1、一对一关联关系的使用

一对一关系在实际生活中是比较常见的，例如学生与学生证的关系，经过学生证能够找到学生。一对一关系在Hibernate中的实现有两种方式，分别是主键关联和外键关联。算法

1．以主键关联

主键关联的重点是，关联的两个实体共享一个主键值。例如，Student与Card是一对一关系，它们在数据库中对应的表分别是t_student和t_card。它们共用一个主键值id，这个主键可由t_student表或t_card表生成。问题是如何让另外一张表引用已经生成的主键值呢？例如，t-student表填入了主键id的值，t_card表如何引用它？这须要在Hibernate的映射文件中使用主键的foreign生成机制。为了表示Student与Card之间的一对一关联关系，在Student和Card的映射文件Student.hbm.xml和Card.hbm.xml中都要使用<one-to-one>标记，如例程1-2所示。数据库

例程1-2 Student.hbm.xml session

< ?xml version="1.0"?>< !DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
    <class name="test.Student" table="T_STUDENT" lazy="true">
        <!-- 把类与表关联起来-->
        <id name="id" column="id" type="int">
            <generator class="increment" />
        </id>
        <property name="name" column="NAME" type="string" />
        <!--property name="card_id" column="CARD_ID" type="int" /-->
        <!--映射学生证号-->
        <property name="sex" column="SEX" type="string" />
        <property name="age" column="AGE" type="int" />
        <one-to-one name="card" class="test.Card" fetch="join" cascade="all" />
    </class>
</hibernate-mapping>

<class>元素的lazy属性设定为true，表示延迟加载，若是lazy的值设置为false，则表示当即加载。下面对当即加载和延迟加载这两个概念进行说明。 app

当即加载：表示Hibernate在从数据库中取得数据，组装好一个对象（好比学生1）后，会当即再从数据库取得数据，组装此对象所关联的对象（例如学生证1）。
延迟加载：表示Hibernate在从数据库中取得数据，组装好一个对象（好比学生1）后，不会当即再从数据库取得数据，组装此对象所关联的对象（例如学生证1），而是等到须要时，才会从数据库取得数据，组装此关联对象。

<one-to-one>元素的cascade属性代表操做是否从父对象级联到被关联的对象，它的取值以下。 eclipse

none：在保存、删除或修改对象时，不对其附属对象（关联对象）进行级联操做。这是默认设置。
save-update：在保存、更新当前对象时，级联保存、更新附属对象(临时对象、游离对象)。
delete：在删除当前对象时，级联删除附属对象。
all：在全部状况下均进行级联操做，即包含save-update和delete操做。
delete-orphan：删除和当前对象解除关系的附属对象。

<one-to-one>元素的fetch属性的可选值是join和select，默认值是select。测试

join：表示链接抓取（Join fetching）： Hibernate经过在SELECT语句使用OUTER JOIN（外链接）来得到对象的关联实例或者关联集合。
select：表示查询抓取（Select fetching）：须要另外发送一条 SELECT 语句抓取当前对象的关联实体或集合。

例程1-3中<one-to-one>元素的cascade属性设置为“all”，表示增长、删除及修改Student对象时，都会级联增长、删除和修改Card对象。 fetch

例程1-3 Card.hbm.xml ui

< ?xml version="1.0"?>
< !DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
    <class name="test.Card" table="t_card" lazy="true">
        <!-- 把类与表关联起来-->
        <id name="id" column="id">
            <generator class="foreign" >
                <param name="property">student</param>
            </generator>
        </id>
        <one-to-one name="student" class="test.Student" constrained="true"/>
        <property name="name" column="name" type="string" />
        <!-- one-to-one name="student" class="test.Student" constrained="true"/-->
    </class>
</hibernate-mapping>

在例程1-3中，Card.hbm.xml的主键id使用外键（foreign）生成机制，引用代号为“student”对象的主键做为Card表的主键和外键。student在该映射文件的<one-to-one>元素中进行了定义，它是Student对象的代号。<one-to-one>元素的属性Constrained="true"表示Card引用了student的主键做为外键。

须要特别注意的是，Student类中要相应地加入一对get/set方法：

public Card getCard() { return this.card; }
public void setCard(Card card) { this.card = card; }

在Card类中也要相应地加入一对get/set方法：

public Student getStudent() { return this.stu; }
public void setStudent(Student stu) { this.stu = stu; }

在客户端测试程序中操纵Student和Card对象的方法如例程1-4所示。例程1-4 客户端测试程序

package test;

import org.hibernate.*;
import org.hibernate.cfg.*;
import java.io.File;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        File file = new File("D://eclipse3.2//workspace//HibernateTest //hibernate.cfg.xml");
        Configuration conf = new Configuration().configure(file);
        SessionFactory sf = conf.buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx = session.beginTransaction(); //新建Student对象
        Student stu = new Student();
        stu.setName("Walker");
        stu.setSex("male");
        stu.setAge(22);

        //新建Card对象
        Card card = new Card();
        card.setName("Walker"); //设置Student对象与Card对象之间的关联
        stu.setCard(card);
        card.setStudent(stu); //此句不能省略，不然card将不知从何处取得主键值
        try {
            session.save(stu); tx.commit();
            session.close();
            System.out.println("Data have been inserted into DB.");
        } catch (HibernateException e) {
            e.printStackTrace();
            tx.rollback();
            session.close();
        }
    }
}

运行以上代码后，将会在t_student表和t_card表中插入相应的数据。

2．之外键关联

之外键关联的要点是：两个实体各自有不一样的主键，但其中一个实体有一个外键引用另外一个实体的主键。例如，假如Student和Card是外键关联的一对一关系，它们在数据库中相应的表分别是t_student表和t_card表，t_student表有一个主键id，t_card表有一个主键id和一个外键stu_id，此外键对应student表的主键id。

Student的映射文件Student.hmb.xml见例程1-2。但Card的映射文件Card.hbm.xml要作相应变更，如例程1-5所示。例程1-5 Card.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class name="test.Card" table="T_CARD" lazy= "true">
        <!--把类与表关联起来-->
        <id name="id" >
            <generator class="increment" >
            <!--再也不是foreign了-->
            </generator>
        </id>
        <property name="name" column="NAME" type="string" />
        <many-to-one name="student" class="Student" column="stu_id" unique="true"/>
        <!--惟一的多对一，实际上变成一对一关系了-->
    </class>
</hibernate-mapping>

在例程1-5中，<many-to-one>元素的name属性声明外键关联对象的代号，class属性声明该外键关联对象的类，column属性声明该外键在数据表中对应的字段名，unique属性表示使用DDL为外键字段生成一个惟一约束。

之外键关联对象的一对一关系，其实本质上变成了一对多的双向关联了，应直接按照一对多和多对一的要求编写它们的映射文件。当<many-to-one>元素的unique属性设定为true，多对一的关系实际上变成了一对一的关系。

在客户端程序中操纵外键关联一对一关系的对象的方法见例程1-4。

2、一对多关联关系的使用

一对多关系很常见，例如父亲和孩子、班级与学生的关系就是很好的一对多的关系。在实际编写程序时，一对多关系有两种实现方式：单向关联和双向关联。单向的一对多关系只需在一方进行映射配置，而双向的一对多须要在关联的双方进行映射配置。下面以Group（班级）和Student（学生）为例讲解如何配置一对多的关系。

1．单向关联

单向的一对多关系只需在一方进行映射配置，因此咱们只配置Group（班级）的映射文件Group.hbm.xml，如例程1-6所示。

例程1-6 Group.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class name="test.Group" table="T_GROUP" lazy="true">
        <!--把类与表关联起来-->
        <id name="id" column="ID"type="int">
            <generator class="increment" >
            </generator>
        </id>
        <property name="name" column="NAME" type="string" update="true" insert="true" />
        <set name="students" table="T_STUDENT" lazy="false" inverse="false" cascade="all" sort="unsorted">
            <key column="ID"/>
            <one-to-many class="test.Student"/>
        </set>
    </class>
</hibernate-mapping>

在以上映射文件中，<property>元素的insert属性表示被映射的字段是否出如今SQL的 INSERT语句中；update属性表示被映射的字段是否出如今SQL的 UPDATE语句中。

<set>元素描述的字段（本例中为students）对应的类型为java.util.Set，它的各个属性的含义以下。

name：字段名，本例的字段名为students，它属于java.util.Set类型。
table：关联表名，本例中，students的关联数据表名是t_student。
lazy：是否延迟加载，lazy=false表示当即加载。
inverse：用于表示双向关联中的被动方的一端，inverse的值为false的一方负责维护关联关系。默认值为false。本例中Group将负责维护它与Student之间的关联关系。
cascade：级联关系；cascade=all表示全部状况下均进行级联操做，即包含save-update和delete操做。
sort：排序关系，其可选取值为unsorted（不排序）、natural（天然排序）、comparatorClass（由某个实现了java.util.comparator接口的类型指定排序算法）。

<key>子元素的column属性指定关联表（本例中t_student表）的外键，<one-to-many>子元素的class属性指定了关联类的名字。

此外，在Group类中增长以下get/set方法：

private Set students; 

public Set getStudents() {
    return this.students; 
}
public void setStudents(Set stu) {
    this.students = stu; 
}

假如咱们想为一个班级添加一个学生对象，实现的代码以下：

Transaction tx = session.beginTransaction();
Student stu = new Student();
stu.setName("Walker");
stu.setSex("male");
stu.setAge(22); 
group.getStudents().add(stu); 
session.save(group); tx.commit();

2．双向关联

若是要设置一对多双向关联，那么还须要在“多”方的映射文件中使用<many-to-one>标记。例如，在Group与Student一对多的双向关联中，除了Group的映射文件Group.hbm.xml和Group类进行设置和修改外，还须要在Student的映射文件Student.hbm.xm中加入：

<many-to-one name="group" class="test.Group" cascade="none" outer-join="auto" update="true" insert="true" column="ID" />

name、class等属性前面已经解释过了，这里只说明insert和update属性。insert和update设定是否对column属性指定的关联字段进行insert和update操做。在Student类还要相应添加一对get/set方法：

public Group getGroup() {
    return this.group;
}
public void setGroup(Group g) {
    this.group = g;
}

此外，把Group.hbm.xml（如例程1-6所示）中的<set>元素的inverse属性的值设定为true，以下所示。

<set name="students" table="T_STUDENT" lazy="false" inverse="true" cascade="all" sort="unsorted">
    <key column="ID"/>
    <one-to-many class="Student"/>
</set>

当Group.hmb.xml中<set>元素的inverse属性的值设定为false时，Group和Student之间的关联关系由Group维护，Group负责将本身的id告诉Student，而后Hibernate发送update语句去更新记录。但如今inverse的值设定为true后，Group和Student之间的关联关系转由Student来维护，由Student自动去取得Group的id，而这个Student取得Group的id的动做，其实就是完成一个“学生添加到班级”的动做。

3、多对多关联关系的使用

Student（学生）和Course（课程）的关系就是多对多的关系。在映射多对多关系时，须要另外使用一个链接表（例如，Student_Course）。Student_Course表包含2个字段：CourseId和StuId。此外，在它们的映射文件中使用<many-to-many>标记。Student的映射文件Student.hbm.xml中加入如下描述信息：

<set name="courses" table=" Student_Course" lazy="false" inverse="false" cascade="save-update" >
    <key column="StuId"/>
    <many-to-many class="test.Course" column="CourseId" />
</set>

相应地，Course的映射文件Course.hbm.xml加入如下描述信息：

<set name="students" table=" Student_Course" lazy="false" inverse="true" cascade="save-update" >
    <key column="CourseId"/>
    <many-to-many class="test.Student" column="StuId" />
</set>

1．添加关联关系

首先让咱们编一个程序来看看一个名为Bill的学生选择了什么课程：

……//得到包含Bill的Student对象Student
stu = (Student)session.createQuery(“from Student s where s.name = ‘Bill’ ”) .uniqueResult(); 

List ls = new ArrayList(stu.getCourses());
for(int i=0; i<ls.size(); i++) {
    Course course = (Course)ls.get(i); //得到Course对象System.out.println(course.getName()); //打印Bill所选课程的清单}…..

如今Bill还想选修business课程，这对于程序员来讲只是为Bill添加了一个到business的关联，也就是说在student_course表中新添一条记录，而T_Student 和T_Course表都不用变动。

……Student stu = (Student) session.createQuery(“from Student s where s.name = ‘Bill’ ”) .uniqueResult();
Course course = (Course) session.createQuery(“from Course c where c.name =‘business’ ”) .uniqueResult(); //设置stu与course的相互关系stu.getCourses().add(course); course.getStudents().add(stu);…..

2．删除关联关系

删除关联关系比较简单，直接调用对象集合的remove()方法删除不要的对象便可。例如，要从学生Bill的选修课清单中删除politics和chemistry两门课，程序以下：

…….Student stu = (Student) session.createQuery("from Student s where s.name = 'Bill' ") .uniqueResult();
Course course1 = (Course) session.createQuery("from Course c where c.name = 'politics' ") .uniqueResult();
Course course2 = (Course)session.createQuery("from Course c where c.name = 'chemistry' ") .uniqueResult();
stu.getCourse().remove(course1); //删除politics课程stu.getCourse().remove(course2); //删除chemisty课程…….

运行以上语句将从student_course表中删除这两条记录，但T_Student和T_Course表没有任何变化。