Java的Hibernate框架中的双向主键关联与双向外键关联

一、双向主键关联
双向的主键关联其实是单向一对一主键关联的一种特殊情况，只不过要在关联对象的两端的映射文件中都要进行<one-to-one>的配置，另外还要在主映射的主键一端采用foreign外键关联属性。
这里同样使用person和idcard来讨论，一个人对应着一个唯一的身份证，而且一个身份证也唯一映射着一个人，所以这就产生了双向的关联关系，person的主键同样也是idcard的主键，分别是主键的同时也是外键，这种关联关系成为双向一对一映射，表现到关系模型中可如下图：

图中的两个表采用了主键关联，person的主键是idcard的主键，所以它们之间构成了朱外键的约束关系，并且保证唯一性，映射到对象模型中，转变为person类和idcard类的一对一关系，如下图：

这种一对一的关系上篇文章中也有讲到用的是<one-to-one>标签，另外这种一对一映射又是双向的，所以要在两个对象之间同时配置<one-to-one>，首先来看idcard对应的类代码和映射文件代码。

1、idcard对应的信息
idcard.java类，idcard类和person类之间有一对一的关联关系所以要在idcard类中添加对应的person属性，这是为了能在映射文件中的外键中添加对应的属性，设置对应的外键关联类。

package com.src.hibernate; 
 
public class idcard { 
   
  //id属性 
  private int id; 
  public int getid() { 
    return id; 
  } 
  public void setid(int id) { 
    this.id = id; 
  } 
   
  //卡号属性 
  private string cardno; 
  public string getcardno() { 
    return cardno; 
  } 
  public void setcardno(string cardno) { 
    this.cardno = cardno; 
  } 
   
  //卡号对应的人 
  private person person; 
  public person getperson(){ 
    return person; 
  } 
  public void setperson(person person){ 
    this.person=person; 
  } 
} 

idcard.hbm.xml映射文件，在映射文件中添加外键属性person，并添加对应的<one-to-one>标签，目的是强制约束person类来实现一对一的映射关系，最后在映射中将constrained属性设为true，保证强制约束关系。

<?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 2014-5-15 23:47:00 by hibernate tools 3.4.0.cr1 --> 
<hibernate-mapping> 
  <class name="com.src.hibernate.idcard" table="idcard"> 
    <id name="id" type="int" column="personid"> 
      <generator class="foreign"> 
        <param name="property">person</param> 
      </generator> 
    </id> 
     
    <property name="cardno" type="string" column="cardno"></property> 
    <one-to-one name="person" constrained="true"></one-to-one> 
  </class> 
</hibernate-mapping> 

2、person对应的信息
person.java类，在该类中除了添加基本的属性外还要添加对应的idcard类作为属性，因为它们之间是一对一的双向关联关系，所以在person类中同样要添加idcard类，相同的道理idcard类中同样添加了person类属性。

package com.src.hibernate; 
 
public class person { 
   
  //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; 
  } 
   
  //idcard 
  private idcard idcard; 
  public idcard getidcard() { 
    return idcard; 
  } 
  public void setidcard(idcard idcard) { 
    this.idcard = idcard; 
  } 
} 

person.hbm.xml映射文件，该文件中主键生成策略没有特殊的要求，因为它和idcard类相互制约的关系，它的主键和外键都是idcard的主键，另外因为是一对一关系所以要在映射文件中添加<one-to-one>标签来标示。

<?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 2014-5-15 23:47:00 by hibernate tools 3.4.0.cr1 --> 
<hibernate-mapping> 
  <class name="com.src.hibernate.person" table="person"> 
    <id name="id" type="int" column="personid"> 
      <generator class="native"></generator> 
    </id> 
     
    <property name="name" type="string" column="personname"></property> 
  <!-- 
  one-to-one标签指示hibernate如何加载其关联对象，默认根据主键加载，也就是拿到关系字段值，根据对端的主键来加载关联对象 
   --> 
  <one-to-one name="idcard"></one-to-one> 
  </class> 
</hibernate-mapping> 

3、hibernate映射文件
上面的类和映射文件配置好后接下来要在hibernate.cfg.xml中配置与数据库映射的信息，需要将两个配置文件添加到hibernate配置文件中，这样在生成对应的数据库时才能找到对应的生成项。

<?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> 
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.driver</property> 
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_one2one_pk1</property> 
    <property name="hibernate.connection.username">root</property> 
    <property name="hibernate.connection.password">1234</property> 
    <property name="hibernate.dialect">org.hibernate.dialect.mysqldialect</property> 
     
    <mapping resource="com/src/hibernate/person.hbm.xml"/> 
    <mapping resource="com/src/hibernate/idcard.hbm.xml" ></mapping> 
  </session-factory> 
</hibernate-configuration> 

 4、生成结果
配置完成后就可以将上面的内容生成对应的数据库了，在数据库中它会按照配置的内容生成相应的表结构，在表中有相应的外键和主键字段。生成表结构时hibernate会在控制台输出相应的sql语句，如下：

alter table idcard drop foreign key fk806f76abac038cd8 
drop table if exists idcard 
drop table if exists person 
create table idcard (personid integer not null, cardno varchar(255), primary key (personid)) 
create table person (personid integer not null auto_increment, personname varchar(255), primary key (personid)) 
alter table idcard add index fk806f76abac038cd8 (personid), add constraint fk806f76abac038cd8 foreign key (personid) references person (personid) 

生成的表结构如下图：

在两张表中同时生成了personid主键，并且也是相应的外键，它同时限制约束了两张表的主键相同且唯一。

5、写入加载测试
生成表后测试下对表的写入和从表中读取数据，编写相应的测试类，测试采用的是单元测试，编写对应的测试方法。
5.1 写入测试
在写入到数据库时一定要注意写入的两个对象都要转化到对应的trainent状态，否则会出现状态转化的错误，测试代码如下：

public void testsave1(){ 
  session session=null; 
  try{ 
    //创建一个会话对象 
    session=hibernateutils.getsession(); 
    //开启会话事务 
    session.begintransaction(); 
     
    //创建person对象，并保存 
    person person=new person(); 
    person.setname("zhangsan"); 
    session.save(person); 
     
    //创建idcard对象，并保存 
    idcard idcard=new idcard(); 
    idcard.setcardno("1111111111111"); 
    idcard.setperson(person); 
    session.save(idcard); 
     
    //提交事务，修改数据库 
    session.gettransaction().commit(); 
     
  }catch(exception e){ 
    //打印错误信息 
    e.printstacktrace(); 
    //业务回滚 
    session.gettransaction().rollback(); 
  }finally{ 
    //关闭会话 
    hibernateutils.closesession(session); 
  } 
} 

插入的数据如下图：

5.2 加载测试
编写加载方法，因为关联关系是双向的，所以相应的加载操作应该是通过一端加载另一端，也就是获取对应的person类，并通过person类来获取对应的idcard信息，相反的也要成立，代码如下：

public void testload1(){ 
  session session=null; 
  try{ 
    //创建一个会话对象 
    session=hibernateutils.getsession(); 
    //开启会话事务 
    session.begintransaction(); 
     
    //获取person对象，并保存 
    person person=(person)session.load(person.class,5); 
    system.out.println("idcard.id: "+person.getidcard().getid()); 
    system.out.println("idcard.cardno: "+person.getidcard().getcardno()); 
     
    //创建idcard对象，并保存 
    idcard idcard=(idcard)session.load(idcard.class, 5); 
    system.out.println("person.id: "+idcard.getperson().getid()); 
    system.out.println("person.name: "+idcard.getperson().getname()); 
     
    //提交事务，修改数据库 
    session.gettransaction().commit(); 
     
  }catch(exception e){ 
    //打印错误信息 
    e.printstacktrace(); 
    //业务回滚 
    session.gettransaction().rollback(); 
  }finally{ 
    //关闭会话 
    hibernateutils.closesession(session); 
  } 
} 

运行上面的测试方法，在控制台打印的相关内容如下：

二、双向外键关联
双向的外键关联可以理解为外键关联的一种特殊情况，这种特殊主要是由于它是一种双向的对应关系，在前篇文章中提到如果想要在一张表中添加一个外键字段的话可以使用<many-to-one>标签，它会关系模型中生成对应的外键列。这里想要实现双向的外键关联就必须使用该标签。
1、对象模型
先来看对象模型，人和身份证属于一对一的关系，一个人对应着一个身份，所以它们之间的多重性是一对一的，并且这种对应关系是双向的。所以它的对象模型同双向主键一对一是相同的，如下图：

2、关系模型
对应的关系模型会发生很大的变化，一对一的外键关联关系会在一张表中生成对应的外键，拿到人和身份证上来说也就是人的关系模型中会有一个身份证号的主键列，它们之间形成了双向的一对一的情况，如下图：

它们之间的对应关系就是上图中看到的，person表中有idcard表的主键，形成了一对一的外键关联关系，而且是双向的，也就是说通过person能够获取到idcard，另外通过idcard也能获取到person。
person对象和idcard对象内的代码同上篇文章中的对象代码一致，不在做代码罗列，唯一不同的是映射文件中的配置问题。
3、映射文件
idcard.hbm.xml映射文件，idcard表不是映射的主表，所以在做一对一的映射时需要使用的是<one-to-one>标签来配置，并且需要制定person关系模型中的外键属性，具体代码如下：

<?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 2014-5-18 22:27:43 by hibernate tools 3.4.0.cr1 --> 
<hibernate-mapping> 
  <class name="com.src.hibernate.idcard" table="idcard"> 
    <id name="id" type="int"> 
      <generator class="native" /> 
    </id> 
    <property name="cardno" type="java.lang.string"> 
      <column name="cardno" /> 
    </property> 
     
    <one-to-one name="person" property-ref="idcard"></one-to-one> 
  </class> 
</hibernate-mapping> 

person.hbm.xml映射文件，person表是映射的主表，需要在该表中添加一个外键属性列来标示idcard表，所以这里需要使用<many-to-one>标签，在person对象中生成相应的外键，并且还要使用unique标明属性唯一。

<?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 2014-5-18 22:27:43 by hibernate tools 3.4.0.cr1 --> 
<hibernate-mapping> 
  <class name="com.src.hibernate.person" table="person"> 
    <id name="id" type="int" column="personid"> 
      <generator class="native" /> 
    </id> 
    <property name="name" type="java.lang.string"> 
      <column name="name" /> 
    </property> 
     
    <many-to-one name="idcard" column="idcardno" unique="true" not-null="true"></many-to-one> 
  </class> 
</hibernate-mapping> 

对象的映射文件配置完成，接下来生成关系模型，sql语句如下：

alter table person drop foreign key fk8c768f55794a52ca 
drop table if exists idcard 
drop table if exists person 
create table idcard (id integer not null auto_increment, cardno varchar(255), primary key (id)) 
create table person (personid integer not null auto_increment, name varchar(255), idcardno integer not null unique, primary key (personid)) 
alter table person add index fk8c768f55794a52ca (idcardno), add constraint fk8c768f55794a52ca foreign key (idcardno) references idcard (id) 

生成的sql语句首先是创建的表，在建表时指定了主键列，创建完成后修改了两个表指定外键属性，形成一对一的关系。

编写测试方法，采用单元测试，加载两个类的对象，并分别从对象的一端获取另一个对象

//加载对象，使用idcard对象装载person对象 
public void testload1(){ 
  session session=null; 
   
  try{ 
    session=hibernateutils.getsession(); 
    session.begintransaction(); 
     
    //获取idcard对象，在idcard中获取与该对象唯一关联的person对象 
    idcard idcard=(idcard)session.load(idcard.class,1); 
    system.out.println("person.id= "+idcard.getperson().getid()); 
    system.out.println("idcard.person.name= "+idcard.getperson().getname()); 
     
    //获取person对象，在person对象中获取与它唯一关联的idcard对象 
    person person=(person)session.load(person.class,1); 
    system.out.println("idcard.id: "+person.getidcard().getid()); 
    system.out.println("idcard.cardno: "+person.getidcard().getcardno()); 
     
    //提交事务 
    session.gettransaction().commit(); 
  }catch(exception e){ 
    e.printstacktrace(); 
    session.gettransaction().rollback(); 
  }finally{ 
    hibernateutils.closesession(session); 
  } 
} 

生成的内容：

对比两种映射关系，主键和外键两种映射，都是双向的映射关系，需要在对象的两端同时配置映射关系，不同的是主键只需要使用<one-to-one>因为它不需要生成属性列，但是必须对表的主键采用foreign的主键生成策略，并标示外键对象；外键的生成策略则需要采用<many-to-one>标签来生成新的外键列。

结语
双向关联中的一对一映射至此已经讨论完成，两篇文章主要讨论了双向关联中的两种用法，其实还是很简单的，记住一句话想要生成外键就使用<many-to-one>标签，如果唯一那就添加unique属性，<one-to-one>标签只是指明了一对一的关系它只是指明一个对象如何加载另一个对象并不在关系模型中添加新列。下篇文章将会对一对多关联展开讨论。