Hibernate检索策略之5.2多对一单向关联检索策略——Hibernate4究竟怎么玩

今天开始多对一单向关联检索策略。

先看一下多端域模型：

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

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.ManyToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.Proxy;

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

/**
 * 
 * @Description 多对一单向关联--单向关联多端
 * @author Bob hehe198504@126.com
 * @date 2012-8-27
 */
@Proxy(lazy = false)
//默认是false,是否延迟加载类级别实例
@Entity
@Table(name = "t_studentum")
public class StudentUM extends BaseDomain {

    private static final long serialVersionUID = 1L;

    private Integer id;

    private String name;

    private ClassUO classUO;

    @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;
    }

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "classid", nullable = false)
    @Cascade(org.hibernate.annotations.CascadeType.SAVE_UPDATE)
    public ClassUO getClassUO() {
        return classUO;
    }

    public void setClassUO(ClassUO classUO) {
        this.classUO = classUO;
    }

    public StudentUM() {
        super();
    }

    public StudentUM(String name, ClassUO classUO) {
        super();
        this.name = name;
        this.classUO = classUO;
    }

}

接下来是一端域模型：

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

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

import javax.persistence.Entity;

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

/**
 * 
 * @Description 多对一单向关联--单向关联一端
 * @author Bob hehe198504@126.com
 * @date 2012-8-27
 */
@Entity
@Table(name = "t_classuo")
public class ClassUO 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 ClassUO() {
        super();
    }

    public ClassUO(String name) {
        super();
        this.name = name;

    }

}

再看一下PO基类，基类通过反射实现了equals(),hasCode()和toString()三个方法，继承该基类的域模型就可以不需要再去实现了。

package com.bao.sample.base.domain;

import java.io.Serializable;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;

/**
 * @Description PO基类实现Serializable接口，以便JVM可以序列化PO实例.利用反射实现了equals(),hasCode()和toString()方法
 * @author Bob hehe198504@126.com
 * @date 2012-7-25
 */
public class BaseDomain implements Serializable {

    private static final long serialVersionUID = 1L;

    public boolean equals(Object obj) {
        return EqualsBuilder.reflectionEquals(this, obj);
    }

    public int hasCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }

    public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }
}

 在讲解检索策略之前呢，先说一下@Entity和@Table注解，前者是标识该类为域模型，在applicationContext.xml中进行如下配置后，程序便会扫描该包下及其子包下的类注解，不同的注解表示不同的组件。

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

@Table与数据库表对应，其属性name的值即为该域模型对应数据表的名称。

先讲@ManyToOne，看一下网上这张图片，延迟和获取选项的等效注解：

在多对一中，@ManyToOne(fetch = FetchType.EAGER)即表示，多端立即加载、一端迫切连接。

下面看一下测试的方法(数据表数据仍然是5.1节中的数据)：

    /**
     * @Description @ManyToOne(fetch = FetchType.EAGER)时检索关联对象
     * 
     */
    @Test
    public void fetchStudentByEager() {
        StudentUMService studentUMService = (StudentUMService) applicationContext
                .getBean("studentUMService");
        StudentUM studentUM = studentUMService.getById(1);

        ClassUO classUO = studentUM.getClassUO();
        System.out.println("迫切连接时关联对象类型:" + classUO.getClass());

        System.out.println(classUO.getId());//①
        System.out.println("------迫切的分割线------");
        System.out.println(classUO.getName());//②

    }

控制台输出的信息：

Hibernate: 
    select
        studentum0_.id as id10_1_,
        studentum0_.classid as classid10_1_,
        studentum0_.name as name10_1_,
        classuo1_.id as id9_0_,
        classuo1_.name as name9_0_ 
    from
        t_studentum studentum0_ 
    inner join
        t_classuo classuo1_ 
            on studentum0_.classid=classuo1_.id 
    where
        studentum0_.id=?
迫切连接时关联对象类型:class com.bao.sample.retrieve.strategy.umto.ClassUO
1
------迫切的分割线------
class one

由此可以看出，检索策略使用迫切连接，多端和一端对象都不是代理类的实例。

当@ManyToOne(fetch = FetchType.EAGER)时,检索的sql语句使用left out join或者inner join方式,具体采用何种方式,根据@JoinColumn(name = "classid", nullable = false)中的nullable属性决定,当nullable=true(默认),会使用left outer join;当nullable=false,会使用inner join.

可以对比一下延迟获取：

    /**
     * @Description @ManyToOne(fetch=FetchType.LAZY)时检索关联对象
     * 
     */
    @Test
    public void fetchStudentByLazy() {
        StudentUMService studentUMService = (StudentUMService) applicationContext
                .getBean("studentUMService");
        StudentUM studentUM = studentUMService.getById(1);

        ClassUO classUO = studentUM.getClassUO();
        System.out.println(classUO.getId());

        System.out.println("------延迟的分割线------");
        System.out.println(classUO.getName());
    }

控制台输出结果：

Hibernate: 
    select
        studentum0_.id as id10_0_,
        studentum0_.classid as classid10_0_,
        studentum0_.name as name10_0_ 
    from
        t_studentum studentum0_ 
    where
        studentum0_.id=?
1
------延迟的分割线------

并有错误提示：org.hibernate.LazyInitializationException: could not initialize proxy - no Session。
已经熟悉了该错误了吧，session关闭了，再去查询时报错。

在解释一下：

当@ManyToOne(fetch=FetchType.LAZY),即从OrderUM导航CustomerUO采用延迟加载时,导航的CustomerUO为一个代理对象,只初始化CustomerUO的标识符,若此时再去调用CustomerUO其他属性时,hibernate会去数据库中进行真正的查询,而getCurrentSesion随事务的提交已经关闭,所以会报org.hibernate.LazyInitializationException: could not initialize proxy - no Session.不能初始化代理类的错误.

今天就到这里。2012-08-30 00:10:23 听雨轩