Hibernate检索策略之5.3.1一对一单向（外键）关联检索策略——Hibernate4究竟怎么玩

一对一关联包括外键关联和主键关联，今天先讲解外键关联。

其实一对一外键单向关联是多对一单向关联的特殊形式，所以两者在使用上除了注解名称上有所差别外，其他都是一样。到这里大家可以将本节和上一节的进行比较学习。

首先仍然是域模型，不过这里我使用其他名称的域模型，husband和wife这两个模型，在中国这个神奇的国度，是宣扬一夫一妻制的，所以。。。你懂得。

一对一单向主动端：

package com.bao.sample.retrieve.strategy.uoto;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Cascade;

import com.bao.sample.base.domain.BaseDomain;

/**
 * @Description:一对一单向外键关联  主动端 proactiveness
 * @author:bao
 * @date:Sep 3, 2012
 */
@Entity
@Table(name = "t_husbanduo")
public class HusbandUO extends BaseDomain {

    private static final long serialVersionUID = 1L;

    private Integer id;
    private String name;
    private WifeUO wife;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @OneToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "wife_id", nullable = false)
    @Cascade(org.hibernate.annotations.CascadeType.SAVE_UPDATE)
    public WifeUO getWife() {
        return wife;
    }

    public void setWife(WifeUO wife) {
        this.wife = wife;
    }

    public HusbandUO() {
        super();
    }

    public HusbandUO(String name, WifeUO wife) {
        super();
        this.name = name;
        this.wife = wife;
    }

}

看到这个Husband域模型，再与上节中的StudentUM多端域模型进行比较，可以发现了除了@ManyToOne修改成@OneToOne，其他真是一点都没变啊（( ⊙ o ⊙ )）

Wife域模型就不在展开占空间了，就是很简单的一个POJO类（当然，加上了一点点非常简单的注解信息）：

package com.bao.sample.retrieve.strategy.uoto;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import com.bao.sample.base.domain.BaseDomain;
/**
 * @Description:一对一外键关联 被动端 passiveness
 * @author:bao
 * @date:Sep 3, 2012
 */
@Entity
@Table(name = "t_wifeuo")
public class WifeUO extends BaseDomain {

    private static final long serialVersionUID = 1L;

    private Integer id;
    private String name;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public WifeUO() {
        super();
    }

    public WifeUO(String name) {
        super();
        this.name = name;
    }

}

当然，仍然应该在applicationContext.xml中进行如下配置后，程序便会扫描该包下及其子包下的类注解，不同的注解表示不同的组件。

    <context:component-scan base-package="com.bao.sample.retrieve.strategy.uoto" />

同时不要忘记在sessionFactory的属性中加入如下信息，否则无法自动找到域模型的。

        <property name="packagesToScan">
            <list>
                <value>com.bao.sample.retrieve.strategy.uoto*</value>
            </list>
        </property>

下面提供了测试方法，有热爱实践的童鞋可以检验一下，俗话说的好啊，实践是检验真理的唯一标准，呵呵。

下面代码是测试延迟加载的。

/**
     * @Description:@OneToOne(fetch=FetchType.LAZY)的效果与@ManyToOne(fetch=FetchType.LAZY)是一样的
     * 解释参见@StudentAndClassServiceTest.fetchStudentByLazy()
     *  void
     */
    //@Test
    public void fetchWifeByLazy() {
        HusbandUOService husbandUOService = (HusbandUOService) applicationContext
                .getBean("husbandUOService");

        HusbandUO husbandUO = husbandUOService.getById(1);
        WifeUO wifeUO = husbandUO.getWife();
        System.out.println(wifeUO.getId());
        System.out.println("------延迟的分割线------");
        System.out.println(wifeUO.getName());
    }

本人亲测，输出结果一并显示，正所谓有图有真相，有代码有基情：

Hibernate: 
    select
        husbanduo0_.id as id11_0_,
        husbanduo0_.name as name11_0_,
        husbanduo0_.wifeid as wifeid11_0_ 
    from
        t_husbanduo husbanduo0_ 
    where
        husbanduo0_.id=?
1
------延迟的分割线------

而下面代码是演示迫切加载：

    /**
     * @Description:@OneToOne(fetch=FetchType.EAGER)的效果与@ManyToOne(fetch=FetchType.EAGER)是一样的
     * 解释参见@StudentAndClassServiceTest.fetchStudentByEager()
     *  void
     */
    @Test
    public void fetchWifeByEager() {
        HusbandUOService husbandUOService = (HusbandUOService) applicationContext
                .getBean("husbandUOService");

        HusbandUO husbandUO = husbandUOService.getById(1);
        WifeUO wifeUO = husbandUO.getWife();
        System.out.println("迫切连接时关联对象类型:" + wifeUO.getClass());
        System.out.println(wifeUO.getId());
        System.out.println("------迫切的分割线------");
        System.out.println(wifeUO.getName());
    }

输出结果：

Hibernate: 
    select
        husbanduo0_.id as id11_1_,
        husbanduo0_.name as name11_1_,
        husbanduo0_.wifeid as wifeid11_1_,
        wifeuo1_.id as id12_0_,
        wifeuo1_.name as name12_0_ 
    from
        t_husbanduo husbanduo0_ 
    inner join
        t_wifeuo wifeuo1_ 
            on husbanduo0_.wifeid=wifeuo1_.id 
    where
        husbanduo0_.id=?
迫切连接时关联对象类型:class com.bao.sample.retrieve.strategy.uoto.WifeUO
1
------迫切的分割线------
wife

今天就到这里，后面接着讲一对一单向主键关联。