延迟加载

1.关于lazy机制： 

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

下面把Customer.hbm.xml文件的<class>元素的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就存在了，不必到数据库中去查询。 

 以下代码先通过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>元素的lazy属性为true，会影响Session的load()方法的各种运行时行为，下面举例说明。 

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

ERROR LazyInitializer:63 -Exception initializing proxy 
net.sf.hibernate.ObjectNotFoundException: No row with thegiven 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: Couldnotinitializeproxy-theowningSessionwasclosed 

由此可见，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: Couldnotinitializeproxy-theowningSessionwasclosed 

2.Hibernate与延迟加载： (好好看)

• 这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的，而且只进行了很少的数据库操作请求，因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个Hibernate会话要在对象使用的时候一直开着。
• lazy延迟加载，其有效期只有在session打开时才有效，session关闭时lazy就没作用了。
• hibernate的lazy loading采用一个HibernateSession来管理session，就是每进行一次数据库操作就新开一个session，操作完成后立马就关闭session，这样做的好处是可以严格关闭session，避免菜鸟级的错误，但Hibernate并不推荐这样做，因为不适合跨方法的事务。 
• 当user—post形成一对多映射，User中包含一个post的list，User中有name，password，phone，有一个list的post，当对post使用懒加载，Hibernate获取对象会获取name，password等基本属性，当需要post，就会从数据库中取，但是session是立即关闭的，这样就会出异常，解决方式之一是在关闭之前调用Hibernate.initalize(user.getPosts)告诉系统，这个是需要懒加载的,但是这破坏了hibernateSession类的封装，后来推荐用

openSessionView模式,把session交给servlet filter来管理,每次有request进来,就开一个session，response结束后关闭，这样session就可以存在整个请求周期了。

3.JPA与延迟加载

设置比较简单，直接在属性上加注解，fetch属性设置成FetchType.EAGER，表示的是即时加载，而Lazy则是懒加载，利用懒加载来调用关联数据，必须要保证主查询session（数据库连接会话）的声明周期没有结束，否则是无法抽到数据的(当然如果把数据都取出来，但不几就没意义了)，当然可以利用Spring提供的@Transactional注解来实现方法内部的操作在同一个数据库连接中执行，

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

最后，我们需要用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); 
} 
} 

转：http://www.cnblogs.com/TTTTT/p/6682304.html