`
aaagu1234
  • 浏览: 148825 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

hibernate 延迟加载问题探讨

阅读更多
但就此说一下关于lazy机制:

延迟初始化错误是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略,那么必须当代理类实例或代理集合处于持久化状态(即处于Session范围内)时,才能初始化它。如果在游离状态时才初始化它,就会产生延迟初始化错误。

下面把Customer.hbm.xml文件的<class></class>元素的lazy属性设为true,表示使用延迟检索策略:



xml 代码
<class name="mypack.Customer" table="CUSTOMERS" lazy="true">  

当执行Session的load()方法时,Hibernate不会立即执行查询CUSTOMERS表的select语句,仅仅返回Customer类的代理类的实例,这个代理类具由以下特征:

(1) 由Hibernate在运行时动态生成,它扩展了Customer类,因此它继承了Customer类的所有属性和方法,但它的实现对于应用程序是透明的。
(2) 当Hibernate创建Customer代理类实例时,仅仅初始化了它的OID属性,其他属性都为null,因此这个代理类实例占用的内存很少。
(3)当应用程序第一次访问Customer代理类实例时(例如调用customer.getXXX()或customer.setXXX()方法), Hibernate会初始化代理类实例,在初始化过程中执行select语句,真正从数据库中加载Customer对象的所有数据。但有个例外,那就是当应用程序访问Customer代理类实例的getId()方法时,Hibernate不会初始化代理类实例,因为在创建代理类实例时OID就存在了,不必到数据库中去查询。

提示:Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具,它能够在程序运行时动态生成扩展 Java类或者实现Java接口的代理类。关于CGLIB的更多知识,请参考:http://cglib.sourceforge.net/。

以下代码先通过Session的load()方法加载Customer对象,然后访问它的name属性:

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getName();
tx.commit();

在运行session.load()方法时Hibernate不执行任何select语句,仅仅返回Customer类的代理类的实例,它的OID为1,这是由load()方法的第二个参数指定的。当应用程序调用customer.getName()方法时,Hibernate会初始化Customer代理类实例,从数据库中加载Customer对象的数据,执行以下select语句:

select * from CUSTOMERS where ID=1;
select * from ORDERS where CUSTOMER_ID=1;

当<class></class>元素的lazy属性为true,会影响Session的load()方法的各种运行时行为,下面举例说明。

1.如果加载的Customer对象在数据库中不存在,Session的load()方法不会抛出异常,只有当运行customer.getName()方法时才会抛出以下异常:

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
mypack.Customer

2.如果在整个Session范围内,应用程序没有访问过Customer对象,那么Customer代理类的实例一直不会被初始化,Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象:

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();

由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化,因此在执行customer.getName()方法时,Hibernate会抛出以下异常:

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed

由此可见,Customer代理类的实例只有在当前Session范围内才能被初始化。

3.net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例,isInitialized()方法用于判断代理类实例是否已经被初始化。例如:

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
if(!Hibernate.isInitialized(customer))
Hibernate.initialize(customer);
tx.commit();
session.close();
customer.getName();

以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例,因此当Session关闭后,可以正常访问Customer游离对象。

4.当应用程序访问代理类实例的getId()方法时,不会触发Hibernate初始化代理类实例的行为,例如:

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getId();
tx.commit();
session.close();
customer.getName();

当应用程序访问customer.getId()方法时,该方法直接返回Customer代理类实例的OID值,无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例,因此当Session关闭后再执行customer.getName()方法, Hibernate会抛出以下异常:

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed


解决方法:

由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的session已关闭掉,就会产生种错误.
在做一对多时,有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在<many-to-one></many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫

failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed


解决方法:在web.xml中加入


xml 代码
<filter>  
   <filter-name>hibernateFilterfilter-name>  
   <filter-class>  
   org.springframework.orm.hibernate3.support.OpenSessionInViewFilter   
   filter-class>  
filter  
<filter-mapping>  
   <filter-name>hibernateFilterfilter-name>  
   <url-pattern>*.dourl-pattern>  
filter-mapping>  

就可以了;

参考了:
Hibernate与延迟加载:

Hibernate对象关系映射提供延迟的与非延迟的对象初始化。非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一起读取出来。这有时会导致成百的(如果不是成千的话)select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候,经常会导致整个数据库都在初始化的阶段被读出来了。当然,你可以不厌其烦地检查每一个对象与其他对象的关系,并把那些最昂贵的删除,但是到最后,我们可能会因此失去了本想在ORM工具中获得的便利。


一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的,而且只进行了很少的数据库操作请求,因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来,所有的数据库逻辑,包括打开或关闭会话,都不能在应用层出现。最常见的是,一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式,将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效,但是在大的系统中,这是一个严重的设计缺陷,妨碍了系统的可扩展性。

在Web层进行延迟加载

幸运的是,Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种方便的解决方法。对那些不熟悉Spring与Hibernate集成使用的人,我不会在这里讨论过多的细节,但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例,Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中,而Filter在Spring之前运行并被配置在web.xml中。不管用哪个,他们都在请求将当前会话与当前(数据库)线程绑定时打开Hibernate会话。一旦已绑定到线程,这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了,Hibernate会话会在Filter的doFilter方法或者Interceptor的postHandle方法中被关闭。下面是每个组件的配置示例:



Interceptor的配置:




xml 代码
<beans>    
<bean id="urlMapping"    
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">    
<property name="interceptors">    
<list>    
<ref bean="openSessionInViewInterceptor"/>    
list>    
property>    
<property name="mappings">    
  
bean>    
  
<bean name="openSessionInViewInterceptor"    
class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">    
<property name="sessionFactory"><ref bean="sessionFactory"/>property>    
bean>    
beans>   


Filter的配置


<web-app></web-app>

<filter></filter>
<filter-name></filter-name>

xml 代码
<web-app>    
  
<filter>    
<filter-name>hibernateFilter</filter-name>    
<filter-class>    
org.springframework.orm.hibernate.support.OpenSessionInViewFilter    
</filter-class>    
</filter>    
  
<filter-mapping>    
<filter-name>hibernateFilter</filter-name>    
<url-pattern>*. spring </url-pattern>    
</filter-mapping>    
  
</web-app>    






实现Hibernate的Dao接口来使用打开的会话是很容易的。事实上,如果你已经使用了Spring框架来实现你的Hibernate Dao,很可能你不需要改变任何东西。方便的HibernateTemplate公用组件使访问数据库变成小菜一碟,而DAO接口只有通过这个组件才可以访问到数据库。下面是一个示例的DAO:


public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {

public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product.class, productId);
}

public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}

public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}


在业务逻辑层中使用延迟加载

即使在视图外面,Spring框架也通过使用AOP 拦截器 HibernateInterceptor来使得延迟加载变得很容易实现。这个Hibernate 拦截器透明地将调用配置在Spring应用程序上下文中的业务对象中方法的请求拦截下来,在调用方法之前打开一个Hibernate会话,然后在方法执行完之后将会话关闭。让我们来看一个简单的例子,假设我们有一个接口BussinessObject:


public    interface    BusinessObject    {
public    void    doSomethingThatInvolvesDaos();
}
类BusinessObjectImpl实现了BusinessObject接口:

public    class    BusinessObjectImpl    implements    BusinessObject    {
public    void    doSomethingThatInvolvesDaos()    {
//    lots of logic that calls
//    DAO classes Which access
//    data objects lazily
}
}



通过在Spring应用程序上下文中的一些配置,我们可以让将调用BusinessObject的方法拦截下来,再令它的方法支持延迟加载。看看下面的一个程序片段:





xml 代码
<beans>    
<bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">    
<property name="sessionFactory">    
<ref bean="sessionFactory"/>    
property>    
bean>    
<bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">    
<property name="someDAO"><ref bean="someDAO"/>property>    
bean>    
<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">    
<property name="target"><ref bean="businessObjectTarget"/>property>    
<property name="proxyInterfaces">    
<value>com.acompany.BusinessObjectvalue>    
property>    
<property name="interceptorNames">    
<list>    
<value>hibernateInterceptorvalue>    
list>    
property>    
bean>    
beans>  


当businessObject被调用的时候,HibernateInterceptor打开一个Hibernate会话,并将调用请求传递给BusinessObjectImpl对象。当BusinessObjectImpl执行完成后,HibernateInterceptor透明地关闭了会话。应用层的代码不用了解任何持久层逻辑,还是实现了延迟加载。


在单元测试中测试延迟加载

最后,我们需要用J-Unit来测试我们的延迟加载程序。我们可以轻易地通过重写TestCase类中的setUp和tearDown方法来实现这个要求。我比较喜欢用这个方便的抽象类作为我所有测试类的基类。


public abstract class MyLazyTestCase extends TestCase {

private SessionFactory sessionFactory;
private Session session;

public void setUp() throws Exception {
super.setUp();
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
session = SessionFactoryUtils.getSession(sessionFactory, true);
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));

}

protected Object getBean(String beanName) {
//Code to get objects from Spring application context
}

public void tearDown() throws Exception {
super.tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}
}



Trackback:http://jiangzi87.blog.ccidnet.com/blog.php?do=showone&itemid=146847&typ=
分享到:
评论

相关推荐

    【北大青鸟内部教程】jsp中关于Hibernate延时加载的问题

    本文将深入探讨在JSP(JavaServer Pages)环境中,如何理解和应对Hibernate的延时加载问题。 首先,我们需要了解什么是延时加载。延时加载是指当实体对象的某个关联属性没有被立即加载,而是等到第一次访问该属性时...

    Hibernate 延迟加载剖析与代理模式应用

    ### Hibernate延迟加载剖析与代理模式应用 #### 一、引言 在现代软件开发中,尤其是在基于Java的企业级应用开发中,Hibernate作为一种流行的ORM(Object Relational Mapping)框架,极大地简化了开发者对数据库的...

    Flex 与 Hibernate 的延迟加载问题

    本文将深入探讨几种解决Flex与Hibernate延迟加载问题的方法,并着重讲解使用Gilead的方案。 1. **LCDS的Hibernate Adapter**:Adobe LiveCycle Data Services (LCDS) 提供了一个Hibernate适配器,可以处理延迟加载...

    Hibernate 延迟加载

    在探讨Hibernate延迟加载之前,我们先简要回顾一下Hibernate框架。Hibernate是一种流行的Java持久层框架,它提供了对象关系映射(ORM)的功能,允许开发者以面向对象的方式操作数据库。而延迟加载(Lazy Loading),...

    Hibernate延迟加载介绍.doc

    《Hibernate延迟加载详解》 Hibernate作为Java领域中的一个强大的对象关系映射框架,提供了许多优化数据库操作的策略,其中之一便是延迟加载(Lazy Loading)。延迟加载机制旨在减少不必要的性能消耗,只在真正需要...

    hibernate延迟加载技术详细解

    本文将详细探讨 Hibernate 的各种延迟加载策略及其应用场景。 #### 二、Fetching 策略 Fetching 策略定义了 Hibernate 在执行查询时如何获取关联的数据。主要有以下几种: 1. **Join Fetching**:这是一种将主表...

    hibernate延迟加载

    ### Hibernate延迟加载详解 #### 一、概述 Hibernate 是一种常用的 Java 持久层框架,它能够将 Java 应用程序与底层数据库之间建立桥梁,简化数据访问逻辑。为了提高应用程序性能,Hibernate 提供了多种优化手段,...

    Hibernate延迟加载案例 (多: 一: 一,附代码)

    本案例主要探讨的是Hibernate的延迟加载(Lazy Loading)机制,这是一种优化数据库访问性能的重要策略。延迟加载允许我们在需要数据时才去加载,而不是在初始化对象时一次性加载所有关联数据,从而减少了内存消耗和...

    hibernate抓取策略和懒加载案例

    在Java的持久化框架Hibernate中,数据访问优化是至关重要的,而抓取策略(Fetch Strategy)和懒加载(Lazy Loading)则是实现这一目标的关键技术。本文将深入探讨这两个概念,并通过具体的案例进行分析。 首先,让...

    Hibernate之数据加载方式

    本篇将深入探讨Hibernate的数据加载方式,帮助开发者更好地理解和掌握其核心机制。 ### 一、基本概念 Hibernate通过实体类与数据库表进行映射,实体类的对象代表了数据库中的记录。数据加载是指从数据库中获取这些...

    hibernate延时

    本文将深入探讨 Hibernate 的延时加载机制,并通过具体的示例来解释其工作原理和配置方法。 #### 二、延时加载的基本概念 延时加载(Lazy Loading)是一种按需加载策略,即只在真正需要某个对象或关联对象的数据时...

    hibernate技术研究对比总结

    文档覆盖了 Hibernate 的核心概念,如对象关系映射、持久化模型、事务处理和查询语言等,并探讨了它在处理复杂数据库结构,如继承关系和关联映射时的策略。 1.3 **读者对象** 该文档适用于 Java 开发者、系统架构师...

    hibernate源码

    本篇将基于提供的文件名,深入探讨Hibernate在对象关系映射(ORM)、数据检索、延迟加载、一对一关联、乐观锁以及缓存策略等方面的关键知识点。 1. **数据检索机制**: 文件`hibernate_fetch_1`与`hibernate_query...

    hibernate aip hibernate aip

    7. **性能优化**:包括延迟加载(Lazy Loading)、批处理(Batch Processing)、缓存策略调整等,这些都可以提升Hibernate应用的性能。 8. **查询优化**:避免N+1查询问题,使用JOIN fetch提前加载关联数据,使用...

    Hibernate 简单 PPT 总结

    - "2018-7-26-Hibernate-加载策略.pptx"可能涉及了Hibernate的对象状态管理,包括延迟加载、立即加载、批处理加载等策略。 - "05-2018-7-9-Hibernate-配置数据库连接池.pptx"可能介绍了如何在Hibernate中配置和使用...

    Hibernate性能优化研究.pdf

    本文旨在通过对Hibernate的深入研究,探讨影响其性能的各种因素,并提出相应的优化策略。 #### 二、O/R Mapping及Hibernate简介 ##### 2.1 O/R Mapping O/R Mapping是一种编程技术,用于在关系数据库和对象之间...

    Hibernate update问题

    本篇文章将深入探讨Hibernate更新机制及其可能遇到的问题,旨在帮助开发者更好地理解和解决这些问题。 1. **基本更新操作** Hibernate通过Session接口的`update()`方法实现对象的更新。当你从数据库加载一个对象...

    Hibernate实战

    懒加载是Hibernate优化性能的一种策略,它延迟加载关联的对象,直到真正需要时才执行数据库查询。缓存机制可以提高数据访问速度,减少数据库负载,包括一级缓存(Session级)和二级缓存(SessionFactory级)。性能...

    hibernate源码release-4.1.4.Final版

    本篇文章将围绕Hibernate 4.1.4.Final版本的源码进行深入探讨,揭示其内部机制,帮助读者提升对Hibernate的理解和应用水平。 一、Hibernate概述 Hibernate是一个开源的ORM框架,它实现了Java持久化模型,将数据库...

Global site tag (gtag.js) - Google Analytics