延时加载和立即加载的区别

什么是延迟加载：所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。可以简单理解为，只有在使用的时候，才会发出sql语句进行查询，数据是分N次读取。

什么是立即加载：所谓立即加载既是所有的相关数据一次被读取出来，而不是分N次。

一、延迟加载：NHibernate延迟加载须有Session存在，且配置为Lazy=true（默认）
DAL中编写方法如下：

        //延迟加载

        public Order LazyLoad()

        {

            //返回order对象后ISession将继续存在

            return session.Get<Order>(2);

           

            //返回order后ISession将会立即被销毁

            //using (ISession iSession = new SessionManager().GetSession())

            //{

            //    Order order = iSession.Get<Order>(2);

            //    return order;

            //}

        }

上面有两种返回order对象的方式，一种返回order后session继续存在，一种在返回order后session就被销毁了，我们先使用未被注释的方法，然后使用被注释了的代码。

 

DAL.Test中编写如下方法：

        [Test]

        public void LazyLoadTest()

        {

            Order order = sample.LazyLoad();

        }

然后设置断点，进行测试调试，在即时窗口编写代码测试。

 

当返回order后session继续存在时，结果如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Customer.Firstname

"soldier"

order.Products.Count

2

这里可以看到，我们可以访问order对象的关联对象Customer和Products

 

当返回order后session立即被销毁时，结果如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Customer.Firstname

“order.Customer.Firstname”引发了“NHibernate.LazyInitializationException”类型的异常

    base {NHibernate.HibernateException}: {"Initializing[Model.Entities.Customer#2]-Could not initialize proxy - no Session."}

    EntityId: 2

    EntityName: "Model.Entities.Customer"

order.Products.Count

“order.Products.Count”引发了“NHibernate.LazyInitializationException”类型的异常

    base {NHibernate.HibernateException}: {"Initializing[Model.Entities.Order#2]-failed to lazily initialize a collection of role: Model.Entities.Order.Products, no session or session was closed"}

    EntityId: 2

    EntityName: "Model.Entities.Order"

这里我们可以访问order对象，这是理所当然的。但是不论我访问order的关联对象Customer还是Products时，都会报“NHibernate.LazyInitializationException”异常，因为访问时使用的是延迟加载，但是session此时已经被销毁了，所以报错，这说明要使用延迟加载就必须保证session是存在的。

 

二、立即加载：有三种方法进行立即加载，一、配置lazy=”false”；二、使用NHibernateUtil类；三、使用带fetch的HQL语句
1)       配置lazy=”false”进行立即加载

首先修改order.hbm.xml文件，将

<bag name="Products" generic="true" table="OrderProduct">

修改为如下：

<bag name="Products" generic="true" table="OrderProduct" lazy="false">

然后再测试，结果如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Products.Count

2

order.Customer.Firstname

“order.Customer.Firstname”引发了“NHibernate.LazyInitializationException”类型的异常

    base {NHibernate.HibernateException}: {"Initializing[Model.Entities.Customer#2]-Could not initialize proxy - no Session."}

    EntityId: 2

    EntityName: "Model.Entities.Customer"

这里可以看到配置了lazy="false"的Products可以访问，因为它的数据已经和order一起读取了，但是当我们访问Customer时，报出了上面我们曾经见到过的错误，因为在order的映射文件里并没有配置Customer为立即加载，所以报错。

 

2)       使用NHibernateUtil类进行强制立即加载

首先修改LazyLoad()函数的代码如下：

            //返回order后ISession将会立即被销毁

            using (ISession iSession = new SessionManager().GetSession())

            {

                Order order = iSession.Get<Order>(2);

                NHibernateUtil.Initialize(order.Customer);                   //这里强制立即加载order的关联Customer对象

                return order;

            }

测试结果如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Products.Count

2

order.Customer.Firstname

"soldier"

哈哈，又可以访问Customer对象了。

 

3)       使用带fetch的HQL查询

a) 使用HQL查询方法也可以立即加载。HQL语句支持的连接类型为：inner join(内连接)、left outer join(左外连接)、right outer join(右外连接)、full join(全连接，不常用)。

b) “抓取fetch”连接允许仅仅使用一个选择语句就将相关联的对象随着他们的父对象的初始化而被初始化，可以有效的代替了映射文件中的外联接与延迟属性声明。

 

几点注意：
c) fetch不与setMaxResults() 或setFirstResult()共用，因为这些操作是基于结果集的，而在预先抓取集合时可能包含重复的数据，也就是说无法预先知道精确的行数。

d) fetch还不能与独立的with条件一起使用。通过在一次查询中fetch多个集合，可以制造出笛卡尔积，因此请多加注意。对多对多映射来说，同时join fetch多个集合角色可能在某些情况下给出并非预期的结果，也请小心。

e)使用full join fetch 与 right join fetch是没有意义的。 如果你使用属性级别的延迟获取，在第一个查询中可以使用 fetch all properties 来强制NHibernate立即取得那些原本需要延迟加载的属性。

 

删除order.hbm.xml中的lazy="false"属性设置，这样order的Products就不是立即加载了，并将LazyLoad()函数修改如下：

        //延迟加载

        public Order LazyLoad()

        {

            //返回order对象后ISession将继续存在

            //return session.Get<Order>(2);

           

            //返回order后ISession将会立即被销毁

            //using (ISession iSession = new SessionManager().GetSession())

            //{

            //    Order order = iSession.Get<Order>(2);

            //    NHibernateUtil.Initialize(order.Customer);

            //    return order;

            //}

 

            //使用HQL的fetch进行立即加载

            using (ISession iSession = new SessionManager().GetSession())

            {

                return iSession.CreateQuery("from Order o left join fetch o.Products where o.OrderId=2 ")

                    .UniqueResult<Order>();

            }

        }

调试测试结果如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Products.Count

2

order.Customer.Firstname

“order.Customer.Firstname”引发了“NHibernate.LazyInitializationException”类型的异常

    base {NHibernate.HibernateException}: {"Initializing[Model.Entities.Customer#2]-Could not initialize proxy - no Session."}

    EntityId: 2

    EntityName: "Model.Entities.Customer"

在上面的HQL语句中通过fetch o.Products语句来立即加载Products，所以测试里可以访问Products，而访问Customer时，则出错了。

 

然后我们修改上面的HQL语句：

"from Order o left join fetch o.Products where o.OrderId=2 "

为如下

"from Order o left join fetch o.Products inner join fetch o.Customer where o.OrderId=2 "

 

并再进行同上面一样的测试看结果如何，我的如下：

order.OrderDate.ToString()

"2009-10-17 11:22:46"

order.Products.Count

2

order.Customer.Firstname

"soldier"

呵呵，都可以访问了，这里很明显地告诉了我们如何fetch关联对象

 

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

下面把Customer.hbm.xml文件的<class>元素的lazy属性设为true，表示使用延迟检索策略：
Xml代码
<class name="mypack.Customer" table="CUSTOMERS" lazy="true"> 

<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属性：
Java代码
tx = session.beginTransaction();  
Customer customer=(Customer)session.load(Customer.class,new Long(1));  
customer.getName();  
tx.commit(); 

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语句：
Sql代码
select * from CUSTOMERS where ID=1;  
select * from ORDERS where CUSTOMER_ID=1; 

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

当<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游离对象：
Java代码
tx = session.beginTransaction();  
Customer customer=(Customer)session.load(Customer.class,new Long(1));  
tx.commit();  
session.close();  
customer.getName(); 

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()方法用于判断代理类实例是否已经被初始化。例如：
Java代码
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(); 

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初始化代理类实例的行为，例如：
Java代码
tx = session.beginTransaction();  
Customer customer=(Customer)session.load(Customer.class,new Long(1));  
customer.getId();  
tx.commit();  
session.close();  
customer.getName(); 

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>里设置lazy="false". 但有可能会引发另一个异常叫

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

解决方法:在web.xml中加入
Xml代码
<filter> 
<filter-name>hibernateFilter</filter-name> 
<filter-class> 
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter  
</filter-class> 
</filter 
<filter-mapping> 
<filter-name>hibernateFilter</filter-name> 
<url-pattern>*.do</url-pattern> 
</filter-mapping>