ORM框架Hibernate (四) 一对一单向、双向关联映射-蒲公英云

简介
1. 在上一篇博客说了一下多对一映射，这里再说一下一对一关联映射，这种例子在生活中很常见，比如一个人的信息和他的身份证是一对一、又如一夫一妻制等等。
2. 记得在Java编程思想上第一句话是“一切皆对象”，生活中的所有事物都是对象，这种一一对应的关系也体现在了对象上，但是在对象上有了些区别这和对象的特性有关系，有了方向性，拿人和身份证来说他们是两个对象，如果是单一方向那么知道了人的信息就能知道身份证信息，相反却得不到。
3. 从实现角度来分也可以分为两种情况，第一种是共享主键；第二种是唯一外键；这两种都很好理解，我们做的系统也不少了平时我们用的那种就是属于唯一外键约束，共享主键是那其中一个表的主键另一个表来用，两个表使用一个相同的主键来保持两个表中记录一一对应。
共享主键方式实现
1. 在维持一对一映射中这种方式用的比较少，可能对于数据库的性能有所提高不需要外键来约束，我们拿人和身份证来说说这种方式怎么实现一对一映射，下面是这两个类的对应关系。
2. 类图
3. Person实体类
  1. package com.bjpowernode.hibernate;
    /**
    - a person information
    - @author LLS
      /
      public class Person {
      //class’s properties
      private int id;
      private String name;
      private Card card;
      //getter and setter method
      public Card getCard() {
```
 return card;
```
      }
      public void setCard(Card card) {
```
 this.card = card;
```
      }
      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;
```
      }
      }

1.  Card实体类
    1.      package com.bjpowernode.hibernate;
            /**
             * a identity card 
             * @author LLS
             *
             */
            public class Card {
                //class properties
                private int id;
                private String cardNo;
                //getter and setter method
                public int getId() {
                    return id;
                }
                public void setId(int id) {
                    this.id = id;
                }
                public String getCardNo() {
                    return cardNo;
                }
                public void setCardNo(String cardNo) {
                    this.cardNo = cardNo;
                }
            }
1.  Person映射文件
    1.      <?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.bjpowernode.hibernate.Person" table="t_person">
                    <id name="id">
                        <!-- 采用foregin策略，它会取得关联对象的标识 -->
                        <generator class="foreign">
                            <!-- property只关联对象 -->
                            <param name="property">card</param>
                        </generator>
                    </id>  
                    <property name="name"></property>
                    <!-- 
                    one-to-one指示Hibernate如何加载其关联对象，默认根据主键加载，也就是拿到了关联字段
                    根据对端的主键来加载。
                    constrained="true"表示当前主键还是一个外键，也就是会生成外键约束语句,当前主键对引用表来说是一个
                    外键，但对当前表是主键
                     -->
                    <one-to-one name="card" constrained="true"></one-to-one>
                </class>
            </hibernate-mapping>
1.  Card映射文件
    1.      <?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.bjpowernode.hibernate.Card" table="t_card">
                    <id name="id">
                        <generator class="native"></generator>
                    </id>
                    <property name="cardNo"></property>
                </class> 
            </hibernate-mapping>
1.  上面是从人到身份证的单向对应关系，如果想实现双向只需在Card类中加入对Person类的引用。另外每个代码中用到的重要属性都做了详细注释，可以参考注释看代码。

唯一外键约束

单向关联（从Person到Card）

还拿上面两个实体类举例代码基本同上面相同，上面已经写的很详细，不同的地方只是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">

<class name="com.bjpowernode.hibernate.Person" table="t_person">
    <id name="id">
        <generator class="native">    
        </generator>
    </id>  
    <property name="name"></property>
    <!-- 
        这里面代码同上一篇博客，多对一映射代码相同，所不同的是加入了unique属性来限制只能是
        一对一。
     --> 
    <many-to-one name="card" column="cardId" unique="true"></many-to-one>
</class>

    3.  当你看到后是不是觉得和多对一映射关系很像呢，其实，它就是多对一的一种特殊情况也是就是多对一包括了一对一这种情况，我们通过加入了unique属性限制只能为一对一，多对一就成了一对一了。
1.  双向关联
    1.  在Card实体以及映射文件中做了一些改动，如下：
    1.  Card实体中加入了对Person的引用
    2.      package com.bjpowernode.hibernate;
            public class Card {
                private int id;
                private String cardNo;
                //加入了对person对象的引用
                private Person person;
                //…………………………同上
                //…………………………同上
            }
    3.  Card映射文件
    4.      <?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.bjpowernode.hibernate.Card" table="t_card">
                    <id name="id">
                        <generator class="native"></generator>
                    </id>
                    <property name="cardNo"></property>
                    <!-- PS -->
                    <!-- property-ref指定对应哪个表的列，如果不设置该属性则默认参照表的主键
                        在person表中的cardId列是参照Card表生成的，反过来，Card表必须也对应cardId列，
                        才能确保一对一关系，但是呢，默认情况会选择参照person表主键，所以，这里加入了property-ref
                        属性来限制一下，参照person表的哪个属性。
                    -->
                    <one-to-one name="person" property-ref="card"></one-to-one>
                </class> 
            </hibernate-mapping>
    5.