关于JAP FetchType.LAZY(hibernate实现)的理解

转载 2011年01月14日 14:24:00

来源:http://www.diwuzhang.com/people-1/article-124/

 

JPA定义实体之间的关系有如下几种:

@OneToOne @ManyToOne @OneToMany @ManyToMany

在定义它们的时候可以通过fetch属性指定加载方式,有两个值:

FetchType.LAZY:延迟加载 FetchType.EAGER:急加载

急加载就好理解了,在加载一个实体的时候,其中定义是急加载的的属性(property)和字段(field)会立即从数据库中加载 开发过程中遇到问题最多的就是延迟加载,并且问题都是一个:

“为什么我定义为延迟加载了,但没起作用,相关的属性或者字段还是会立即加载出来?”

对于这个问题,我的理解是这样的,我们首先假设有如下的影射关系:

	@Entity
@Table(name = "orders")
class Order{

  @OneToMany(cascade = {CascadeType.MERGE,CascadeType.PERSIST,CascadeType.REFRESH},fetch = FetchType.LAZY,mappedBy = "order")
  private Collection
 lineItems = new HashSet
();

  @OneToOne(cascade={CascadeType.REMOVE},fetch=FetchType.LAZY,mappedBy="order")
  @JoinColumn(name="order_id")
  private OrderPrice salePrice;

  @OneToOne(cascade={CascadeType.REMOVE},fetch=FetchType.LAZY)
  @JoinColumn(name="customer_id")
  private Customer customer;
}

@Entity
@Table(name = "order_items")
class LineItem{

  @ManyToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST,
  CascadeType.REFRESH},fetch = FetchType.LAZY)
  @JoinColumn(name = "order_id",referencedColumnName = "order_id")
  private Order order;

}

@Entity
@Table(name = "order_finance")
@AttributeOverride(name="id",column=@Column(name="order_id"))
class OrderPrice extends Price{

  private Order order;

  @OneToOne(cascade={},fetch=FetchType.LAZY)
  @JoinColumn(name="order_id",referencedColumnName="order_id")
  public Order getOrder() {
    return order;
  }

  public void setOrder(Order order) {
   this.order = order;
  }

}

@MappedSupperclass
@Table(name = "order_finance")
class Price{
   @Id
   public Integer getId(){
      ...
  }
}

表的关系是:orders表是一个单独的表,order_items表有一个外键(order_id)引用到orders表,order_finance有一个外键(order_id)引用到orders表. order_items------->orders<------------order_finance

customer

现在的问题就是:
Order.lineItems 这个@OneToMany的LAZY延迟加载是起作用的,find order的时候没有find出lineItems
Order.customer 这个@OneToMany的LAZY延迟加载是起作用的,find order的时候没有find出Customer
Order.salePrice 这个@OneToOne的LAZY延迟加载没起作用,find order后会把相关的OrderPrice也fetch 出来
LineItem.order 这个@ManyToOne的LAZY延迟加载是起作用的,find lineitem没有把相关的order find出来
OrderPrice.order 这个@OneToOne的LAZY延迟加载没起作用,find orderprice的时候把相关的order find出来了

延迟加载,顾名思义,就是在访问具体的属性时才从数据库中加载,比如例子中,只有调用OrderPrice.getOrder()的时候才应该会加载Order这个实体,加载OrderPrice的时候是不应该加载Order的。

那么首先想想,对于延迟加载,hibernate怎么知道什么时候会调用到相关的实体的get方法呢?
答案是它不知道,hibernate不知道什么时候会调用到相关的get方法,那么hibernate如何实现只有访问到才加载这一点? hibernate使用了代理(Proxy),对实体的调用会被代理接受和处理,hibernate可以设置这个代理被调用到的时候去加载数据,从而实现延迟加载。那么对于一个映射对象,要么它有值,要么它是null,对于null值建立代理是没多大作用的,而且也不能对null建立动态代理。那就是说hibernate在对延迟加载建立代理的时候要考虑这个映射的对象是否是null。如果是null不需要建立代理,直接把映射的值设置成null,如果映射的对象不为null,那么hibernate就建立代理对象

延迟加载失败都是由于确定映射的内容是否是null引起的 先来看@OneToMany,比如例子中的Order.lineitems,这是一个Collection,hibernate在加载Order的时候不加载lineitems,而是创建一个代理(Proxy)一个针对Collection的代理(通常是org.hibernate.collection.persistentBag。除非你调用了像Order.getLineItems.size()或者Order.getLineItems.get()方法的时候hibernate才会去加载这个order的lineitems数据,要不然只是调用Order.getLineItems是不会加载到数据的,因为这个时候并没有具体的访问LineItem. 由于代理是针对Collection建立的,而不是针对实体建立的,hibernate不用太多考虑是否为null,如果lineitem没有,也只是代表这个集合是长度是0,这个集合是不为Null的。所以这很容易实现延迟加载

现在在来看例子@OneToOne Order.salePrice。它为什么会失败呢? hibernate也会建立代理,但这个代理是针对OrderPrice建立的(如果延迟加载成功,这个代理类形如Customer_javasisst_$1),默认optioanl=true,也就是说OrderPrice可以为null,那么hibernate就要考虑,这里是放一个null呢?还是放一个代理。但在Order这个实体里是不能确定它有没有价格的(但在价格里知道他的Order,有个外键指向order),所以hibernate要确认这个OrderPrice是否存在,这个确认就导致的延迟加载失败,因为OrderPrice要被查询一次,如果不存在映射值为null,如果存在这个时候值都取出来了,当然就不用什么代理了

Order.customer延迟加载是成功的,order表有一个外键关联到customer表,hibernate应该从这里知道这个customer是确实存在的,不用把映射值设置成null了,可以设置成代理类Customer_javasisst_$2

那如果把Order.salePrice的映射定义修改成:
@OneToOne(cascade={CascadeType.REMOVE},fetch=FetchType.LAZY,optional=false,mappedBy="order") @JoinColumn(name="order_id")
private OrderPrice salePrice;
延迟加载就成功了,因为optional=false指定salePrice不是可选的,必须有值,所以hibernate也不用考虑是该放null还是放代理,既然必须有值,又是延迟加载,那就设置成代理类了

根据上面所说的,OrderPrice定义有一个外键关联到Order,那OrderPrice.order这个延迟加载应该是成功的,但为什么会失败呢? 难道是Order与OrderPrice两边都定义了OneToOne关系? 我这个例子中,这里失败我想是因为OrderPrice这个实体的定义:@AttributeOverride(name="id",column=@Column(name="order_id"))

再来看看ManyToOne的LineItem.order,这个延迟加载也是成功的。因为lineitem定义了外健关系到order 对于延迟加载的对象,如果已经脱离了容器,调用会得到org.hibernate.LazyInitializationException: could not initialize proxy - no Session方法异常

还有一种情况下延迟加载“看起来是没起作用的”:其实是起作用的,但可能在什么地方的代码调用到了相关的get方法,把延迟加载的对象加载出来的,所以看起来是没有成功的

总结:

  • 对于延迟加载,hibernate无法知道什么时候会调用到延迟加载的属性/字段的get方法,所以对于延迟加载的属性/字段,hibernate会通过建立代理Proxy来包装(Wrapper)一下
  • 代理可能会根据实体本身建立,也可以是根据一个集合建立,如果是根据一个集合建立,延迟加载一般都能成功,如果是根据实体建立,null是不能建立代理的,如果能够确定代理类一定存在,那延迟加载就能成功,相关的映射放置的是代理类,如果不能确定映射的属性是否存在,那就会去数据库中进行查询,这就导致的延迟失败。 外键定义可以让hibernate知道映射的属性是否存在 也可以通过optional=false来告诉hibernate,映射的属性一定存在

hibernate 普通字段延迟加载无效的解决办法(如:Lazy Fetch Blob)

http://blog.csdn.net/dys1990/article/details/38728175 http://stackoverflow.com/questions/2605477/spr...
  • qq804702802
  • qq804702802
  • 2015年10月20日 17:29
  • 1038

(八)Hibernate之JAP使用

这次讲的JPA前一篇文章都有所介绍,这里呢就是结合hibernate.cfg.xml来讲讲,怎么用JPA进行CURD操作,类似于Hibernate的session进行CURD操作 hiber...
  • yyw6637
  • yyw6637
  • 2013年04月10日 07:16
  • 1165

hibernate 普通字段延迟加载无效的解决办法

关联对象的延迟加载就不说了,大家都知道。 关于普通
  • dys1990
  • dys1990
  • 2014年08月21日 12:54
  • 4395

hibernate☞FetchType关联关系的加载策略

hibernate的对关联关系有两种加载方式:Lazy懒加载,Eager急加载 懒加载:即在用到的时候进行加载; 急加载:在实体加载的同时就对该属性进行加载; 1. 懒加载的配置 ...
  • king624498030
  • king624498030
  • 2015年08月05日 14:23
  • 1487

Hibernate与Jpa的关系,终于弄懂

原文链接:http://blog.sina.com.cn/s/blog_5f1619e80100yoxz.html 我知道Jpa是一种规范,而Hibernate是它的一种实现。除了Hiberna...
  • caiyanzhi123
  • caiyanzhi123
  • 2016年03月08日 15:53
  • 4698

面试题:谈谈你对hibernate的理解

说说这类问题一般要和一个东西比较,说说他们的优点和缺点,hibernate就和JDBC比较呗,你就说说JDBC的优缺点,然后说说hibernate的优缺点,最后对比得出hibernate更好。 ...
  • u012110719
  • u012110719
  • 2015年06月07日 19:37
  • 6834

对hibernate的简单理解

hibernate的简单理解
  • Forever1026
  • Forever1026
  • 2016年03月07日 09:55
  • 906

hibernate深入理解-点滴记录

1.什么是hibernate  方言,如何配置方言? 通常我们会在hibernate.cfg.xml文件中这样配置: org.hibernate.dialect.Oracle10gDialect ...
  • zy846771221
  • zy846771221
  • 2015年10月20日 17:14
  • 632

FetchType.LAZY和FetchType.EAGER什么区别?(懒加载和急加载的理解)

1、FetchType.LAZY:懒加载,加载一个实体时,定义懒加载的属性不会马上从数据库中加载。 2、FetchType.EAGER:急加载,加载一个实体时,定义急加载的属性会立即从数据库中加载。...
  • u010082453
  • u010082453
  • 2015年01月31日 09:55
  • 4996

jackson java转json hibernate懒加载造成的无限递归问题

@JsonIgnore @JsonFilter @JsonBackReference @JsonManagedReference @JsonIgnoreProperties jackson中的@Jso...
  • cym19890801
  • cym19890801
  • 2015年11月05日 11:11
  • 3219
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:关于JAP FetchType.LAZY(hibernate实现)的理解
举报原因:
原因补充:

(最多只允许输入30个字)