Java的Hibernate框架中一对多的单向和双向关联映射

一、一对多单向关联映射

一对多关系的对象模型在日常生活中也经常看到，就拿学生和班级来说，一个班级里有多个学生，所以班级和学生的关系是一对多的关系，映射到对象模型中，如下图：

对象模型说明了这种一对多的关系是由一的一端来维护的，那么映射成关系模型就是一个班级字段下面会有多个学生，这样就形成了一对多的关系，通过班级能够查询获得学生信息，对应的关系模型如下图：

1、基本配置

有了对象模型接下来就让它们映射为对应的关系代码，在进行关系映射时需要在一的一端添加<one-to-many>标签，另外还需要在一的一端添加set属性，它支持延迟加载，然后在映射文件添加set标签，并指明一对多的关系，这样就能够在一的一端查询获取多的一端。

classes类及映射文件：
它是模型中最重要的一端，在该端需要添加对应的set属性，并在配置文件中添加set标签，在set标签中配置相应的<one-to-many>对象，具体classes.java对象代码如下：

package com.src.hibernate; 
 
import java.util.set; 
 
public class classes { 
  private int id; 
  public int getid() { 
    return id; 
  } 
  public void setid(int id) { 
    this.id = id; 
  } 
  public string getname() { 
    return name; 
  } 
  public void setname(string name) { 
    this.name = name; 
  } 
  private string name; 
   
  //set支持延迟加载 
  private set students; 
  public set getstudents() { 
    return students; 
  } 
  public void setstudents(set students) { 
    this.students = students; 
  } 
} 

classes对象中使用了set属性，但是只是说明了延迟加载的属性，并没有为属性配置对应的对象，属性的对象是要在映射文件中来配置的，需要添加set标签，并在set标签中添加<one-to-many>标签，具体如下代码：

<?xml version="1.0"?> 
<!doctype hibernate-mapping public  
  "-//hibernate/hibernate mapping dtd 3.0//en" 
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
  <class name="com.hibernate.classes" table="t_classes"> 
    <id name="id"> 
      <generator class="native"/> 
    </id> 
    <property name="name"/> 
    <set name="students"> 
      <key column="classesid"></key> 
      <one-to-many class="com.hibernate.student"></one-to-many> 
    </set> 
  </class> 
</hibernate-mapping> 

对应的student对象中的代码和映射文件不需要什么特殊的配置，只需要按照通常的写法编写即可，具体的配置方法不再详述，很简单。配置好后需要生成对应的sql语句，将对象模型转化为关系模型时hibernate生成相应的语句如下：

alter table t_student drop foreign key fk4b9075705e0afefe 
drop table if exists t_classes 
drop table if exists t_student 
create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id)) 
create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id)) 
alter table t_student add index fk4b9075705e0afefe (classesid), add constraint fk4b9075705e0afefe foreign key (classesid) references t_classes (id) 

生成的对应的关系模型如下图：

对比sql语句和关系模型，相应的表之间的关联是通过外键来维护的，首先是创建两张表，并指定表的主键，最后添加一对多的外键关联关系。

2、基本操作
在对数据库的操作无非是读和写两种，修改也属于写的一种，接下来看看是如何向数据库中写入和读取操作的。

（1）写入数据：
写入数据需要注意的是一对多的关系，所以在添加的时候需要添加多个学生类，另外由于在classes中添加了对应的set属性，所以在添加student对象时应该使用hashset来添加，这样既可实现一对多的关系，具体如下代码：

public void testsave2(){ 
  session session=null; 
  try{ 
    session=hibernateutils.getsession(); 
    session.begintransaction(); 
     
    student student1=new student(); 
    student1.setname("zhangsan"); 
    session.save(student1); 
     
    student student2=new student(); 
    student2.setname("lisi"); 
    session.save(student2); 
     
    classes classes=new classes(); 
    classes.setname("classone"); 
     
    set students=new hashset(); 
    students.add(student1); 
    students.add(student2); 
     
    classes.setstudents(students); 
    //可以成功保存数据 
    //但是会发出多余的update语句来维持关系，因为是一对多的原因 
    session.save(classes); 
    session.gettransaction().commit(); 
  }catch(exception e){ 
    e.printstacktrace(); 
    session.gettransaction().rollback(); 
  }finally{ 
    hibernateutils.closesession(session); 
  } 
} 

那么运行上面的测试用例生成的对应的数据写入到数据库中后如下图：

（2）读取数据：
写入操作相对简单，只需要把所有加载的对象都添加到transient状态下，运行相应的方法就可以插入内容，但是对应的读取操作就会稍微复杂点，因为需要迭代获取所有的学生对象，所以这种一对多的关系效率并不很高，具体代码如下：

package com.test.hibernate; 
 
import java.util.iterator; 
import java.util.set; 
import com.src.hibernate.*; 
import junit.framework.testcase; 
import org.hibernate.session; 
 
public class one2manytest extends testcase { 
  public void testload1(){ 
    session session=null; 
    try{ 
      session=hibernateutils.getsession(); 
      session.begintransaction(); 
       
      //获取主键为5的班级信息 
      classes classes=(classes)session.load(classes.class,5); 
      //打印班级信息 
      system.out.println("classes.name="+classes.getname()); 
      //设置学生集合，通过班级加载学生集合 
      set students=classes.getstudents(); 
      //迭代集合，打印集合中学生的信息 
      for(iterator iter=students.iterator();iter.hasnext();){ 
        student student=(student)iter.next(); 
         
        system.out.println("student.name="+student.getname()); 
      } 
       
      session.gettransaction().commit(); 
    }catch(exception e){ 
      e.printstacktrace(); 
      session.gettransaction().rollback(); 
    }finally{ 
      hibernateutils.closesession(session); 
    } 
  } 
} 

生成的相应的语句及信息如下语句：

hibernate: select classes0_.id as id1_0_, classes0_.name as name1_0_ from t_classes classes0_ where classes0_.id=? 
classes.name=classone 
hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id0_0_, students0_.name as name0_0_ from t_student students0_ where students0_.classesid=? 
student.name=lisi 
student.name=zhangsan 

二、一对多双向关联映射
这里继续采用学生和班级作为示例，班级和学生之间是一对多的关系，一个班级中拥有多名学生，和上篇文章不同的是这里的关系是双向的，也就是一的一端和多的一端同时维护关联关系，所以它的对象图如下：

对应的关系模型图没有太大的变化，因为它们之间的关系是双向的，所以在关系模型中两端同时维护关联关系，映射到关系模型中如下图所示：

在一对多的单向关联中映射文件只需要在一的一端进行特殊配置就可以，使用<one-to-many>配置，并在对象模型中使用set迭代器来设置外联的对象模型，但是不同的是在双向的关联中需要在多的一端添加对应的另一端的外键关联，这时候就必须在多的一端使用<many-to-one>的关联关系来标明这种双向性。

1、映射

这里还使用classes和student来做示例，在classes一端的内容和上文相同不会发生变换，但是多的一端student的配置会发生变化，也就是在映射文件中需要添加<many-to-one>标签。
student.hbm.xml映射文件配置需要添加外键列<many-to-one>标签，并且该列的名称要和classes.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"> 
<hibernate-mapping> 
  <class name="com.src.hibernate.student" table="t_student"> 
    <id name="id"> 
      <generator class="native"/> 
    </id> 
    <property name="name"/> 
    <!-- 在多的一端student中添加一行新的classes列 ,并且列的名称要和classes.hbm.xml的列明相同--> 
    <many-to-one name="classes" column="classesid"></many-to-one> 
  </class> 
</hibernate-mapping> 

classes.hbm.xml映射文件的配置和上篇文章相同，需要注意的是在classes.java文件中添加了set属性映射对应了student对象，所以在映射文件中需要添加set标签来指示为对象模型中使用了set迭代器，具体配置如下代码：

<?xml version="1.0"?> 
<!doctype hibernate-mapping public  
  "-//hibernate/hibernate mapping dtd 3.0//en" 
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
  <class name="com.src.hibernate.classes" table="t_classes"> 
    <id name="id"> 
      <generator class="native"/> 
    </id> 
    <property name="name"/> 
    <set name="students" inverse="true"> 
      <key column="classesid"></key> 
      <one-to-many class="com.src.hibernate.student"></one-to-many> 
    </set> 
  </class> 
</hibernate-mapping> 

2、类

映射文件的配置是直接对应着类来的，所以有了映射文件就能够写出相应的类，相同的有了类就能够知道对应的映射文件如何编写，那来看看相应的类代码如何编写。
student.java类，需要在类中添加关联的班级对象属性，在加载student时能获得classes的相关信息。

package com.src.hibernate; 
 
public class student { 
   
  //关联的班级对象 
  private classes classes; 
  public classes getclasses() { 
    return classes; 
  } 
  public void setclasses(classes classes) { 
    this.classes = classes; 
  } 
   
  //学生id 
  private int id; 
  public int getid() { 
    return id; 
  } 
  public void setid(int id) { 
    this.id = id; 
  } 
   
  //学生姓名 
  private string name; 
  public string getname() { 
    return name; 
  } 
  public void setname(string name) { 
    this.name = name; 
  } 
   
} 

classes.java文件具体代码内容见上篇文章，这里就不在详述。
有了对象模型接下来生成关系模型，生成的sql语句如下：

alter table t_student drop foreign key fk4b907570fc588bf4 
drop table if exists t_classes 
drop table if exists t_student 
create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id)) 
create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id)) 
alter table t_student add index fk4b907570fc588bf4 (classesid), add constraint fk4b907570fc588bf4 foreign key (classesid) references t_classes (id) 

3、数据操作

建立表结构后来编写测试方法来验证数据的操作，首先来看看数据的插入，向表结构中插入数据，写入数据时会有两种情况，一种是首先创建一个classes对象，并将对象写入到数据库中，然后创建student对象，在classes对象中添加学生对象；另外一种是先创建学生对象，并将学生对象写入数据库中，然后创建classes对象将学生对象加入到classes对象中，这两种类型的操作最后是不相同的，来对比下。

3.1 先写班级后写学生
先把班级写入到数据库中后，classes对象进入了transient状态，并在数据库中有了一行，这时再写student对象，student对象会查找对应的classes的主键将其写入到表中，所以此时关系模型中的数据都是非空的，保存的代码如下：

public void testsave(){ 
  session session=null; 
  try{ 
    //创建session对象 
    session=hibernateutils.getsession(); 
    //开启事务 
    session.begintransaction(); 
    //创建班级对象，将班级对象写入到数据库中 
    classes classes=new classes(); 
    classes.setname("class"); 
    session.save(classes); 
    //创建学生1对象，将学生对象写入到数据库中 
    student student1=new student(); 
    student1.setname("zhangsan"); 
    student1.setclasses(classes); 
    session.save(student1); 
    //创建学生2对象，将学生对象写入到数据库中 
    student student2=new student(); 
    student2.setname("lisi"); 
    student2.setclasses(classes); 
    session.save(student2); 
     
    session.gettransaction().commit(); 
  }catch(exception e){ 
    e.printstacktrace(); 
    session.gettransaction().rollback(); 
  }finally{ 
    hibernateutils.closesession(session); 
  } 
} 

对应的写入数据库中的信息列表如下图：

3.2 先写学生后写班级
先把学生写入到数据库中此时因为学生表需要获取对应的班级列的主键信息，但是因为班级信息转化到transient状态，所以在写入学生信息时会有null值，代码如下：

写入后对应的数据库视图如下：

 对比两种写入操作，因为两个写入的先后顺序不同所以出现了不同的结果，但因为是双向的关联关系所以在写入时并不会发生异常。
   
4、读取操作

相对于写入数据而言，读取数据就变得很简单了，因为是双向的关联所以数据的读取也是双向的，可以从任何一端读取另一端的信息，如下代码：

public void testload1(){ 
  session session=null; 
  try{ 
    session=hibernateutils.getsession(); 
    session.begintransaction(); 
     
    //通过班级读取学生信息 
    classes classes=(classes)session.load(classes.class,1); 
    system.out.println("classes.name="+classes.getname()); 
    set students=classes.getstudents(); 
     
    for(iterator iter=students.iterator();iter.hasnext();){ 
      student student=(student)iter.next(); 
      system.out.println("student.name="+student.getname()); 
    } 
     
    //通过学生信息读取班级信息 
    student stu=new student(); 
    stu=(student)session.load(student.class, 1); 
    system.out.println("通过学生加载班级信息classes.id= "+stu.getclasses().getid()); 
    session.gettransaction().commit(); 
  }catch(exception e){ 
    e.printstacktrace(); 
    session.gettransaction().rollback(); 
  }finally{ 
    hibernateutils.closesession(session); 
  } 
} 

运行上面的测试语句，生成的对应的语句信息如下：

hibernate: select classes0_.id as id1_0_, classes0_.name as name1_0_ from t_classes classes0_ where classes0_.id=? 
classes.name=class 
hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id0_0_, students0_.name as name0_0_, students0_.classesid as classesid0_0_ from t_student students0_ where students0_.classesid=? 
student.name=lisi 
student.name=zhangsan 

通过学生加载班级信息classes.id= 1