http://blog.csdn.net/sanjy523892105/article/details/7071139
懒加载为Hibernate中比较常用的特性之一，下面我们详细来了解下懒加载的原理和注意事项
Load()方法的懒加载原理
在Hibernate中，查询方法有两个，分别是get()和load()，这两种方法的不同就是load()拥有懒加载的特性。Load()方法就是在查询某一条数据的时候并不会直接将这条数据以指定对象的形式来返回，而是在你真正需要使用该对象里面的一些属性的时候才会去数据库访问并得到数据。他的好处就是可以减少程序本身因为与数据库频繁的交互造成的处理速度缓慢。
以一个Person类做例子，我们写一个查询的方法如下：
public static void query(int id){
Session session=null;
try{
session=HibernateUtil.getSession();
Person person=(Person) session.load(Person.class, id);
//System.out.println(person.getName());
}catch(HibernateExceptionex){
ex.printStackTrace();
}finally{
if(session!=null){
session.close();
}
}
}
然后在Hibernate配置文件中添加以下属性
<property name="hibernate.show_sql">true</property>
这条属性的作用为将Hibernate运行时产生的每一条SQL语句都打印出来
运行上述方法后，我们并没有看到Hibernate打印任何查询语句，这时我们可以将注释的语句重新调回来，让他打印查询到的person的name。这时我们可以看到Hibernate产生的查询语句并看到person的name属性。这就是懒加载了。
那么在Hibernate懒加载的时候，返回的对象是空的吗？答案是否定的，我们可以通过打印person.getClass()方法来验证，打印出来的结果并不是null，而是一个Person后面加了一堆很奇怪的字符的类。可以肯定的是懒加载的对象并不是空，而且这个对象的类型不是Person类。那么他到底是什么呢？
其实这个兑现我们管它叫做代理对象，而这个对象所属的类是Person类的子类，是Hibernate自动实现的一个子类。这个子类的特点是：当你访问person对象的某一个属性的时候，他会自动查询数据库中对应这个对象的数据并返回，这就是为什么在创建对象关系映射的时候要求实体类不能够为final类型的原因了。
但是这个对象是有一个生命周期的，我们可以改写上述方法如下：
public static Person query(int id){
Session session=null;
Person person=null;
try{
session=HibernateUtil.getSession();
person=(Person)session.load(Person.class, id);
//System.out.println(person.getName());
}catch(HibernateExceptionex){
ex.printStackTrace();
}finally{
if(session!=null){
session.close();
}
}
return person;
}
调用这个方法并返回查询到的代理对象，我们可以在返回该对象后打印该对象的name属性，这时会抛出一个org.hibernate.LazyInitializationException异常
这就是懒加载不能初始化异常，这就说明了一件事，懒加载的时候如果想通过代理对象查询数据库，需要在该session关闭以前才可以。但如果一定要在session关闭以后再使用代理对象的话，Hibernate中定义了一个初始化代理对象的方法initialize()，通过该方法即可将代理对象初始化。
注：在使用代理对象的getId()方法和getClass()方法的时候，并不会抛出不能初始化异常，因为这两个属性并不用查询数据库。
懒加载可以用于关系映射和集合属性的操作，而且懒加载是可以关闭并打开的，下面我们会根据不同的情况分析一下懒加载。
一对一的懒加载分析
一对一的懒加载并不常用，因为懒加载的目的是为了减少与数据库的交互，从而提高执行效率，而在一对一关系中，主表中的每一条数据只对应从表的一条数据库，就算都查询也不会增加多少交互的成本，而且主表不能有contrained=true，所以主表是不能懒加载的。（从表可以有）
注：当fetch设置为join时，懒加载就会失效。因为fetch的作用是抓取方式，他有两个值分别问select和join，默认值为select。即在设为join时，他会直接将从表信息以join方式查询到而不是再次使用select查询，这样导致了懒加载的失效。
一对多和多对多的懒加载分析
与一对一关联不同，一对多和一对多的关联下，主表的每一条属性都会对应从表的多条数据，这个时候懒加载就显得非常有效了。比如一个部门里面有多个员工，如果没有懒加载，每查询这个部门的时候都会查询出多个员工，这会大大增加与数据库交互的成本。所以Hbernate默认的是加入懒加载的。这就是查询集合属性的时候返回的是一个PersistentIndexed*类型对象的原因。该对象其实就是一个代理对象。当然，可以在映射文件中通过将lazy属性设为假来禁用。
多对一的懒加载分析
虽然多对一与一对一关系方式相同，但是在Hibernate中多对一时，默认是进行懒加载的。另外有一点需要注意的是懒加载并不会区分集合属性里面是否有值，即使是没有值，他依然会使用懒加载，这也是懒加载不够完善的地方之一。
懒加载的一些细节扩充
有的时候，我们在session关闭后仍需要使用懒加载的代理对象来查询数据库，这时我们就需要将代理对象初始化，不过问题是，当我们不能确定初始化后就一定使用该对象的时候怎么办，这样不是又白白浪费了资源吗？我们可以在使用代理对象的方法里面加入一个布尔值参数，这样当我们不需要初始化代理对象的时候只要将布尔参数设为假。但也是有缺点的，因为在调用的时候，尤其是在别人使用的时候，参数越多，方法学习成本就会增加，所以请酌情处理。
懒加载也可以用于某些简单属性，但是因为实现起来比较复杂，而且效果并不明显，所以并不推荐。
http://blog.csdn.net/yaorongwang0521/article/details/7074573
Hibernate懒加载解析
在Hibernate框架中，当我们要访问的数据量过大时，明显用缓存不太合适， 因为内存容量有限 ，为了减少并发量，减少系统资源的消耗，这时Hibernate用懒加载机制来弥补这种缺陷，但是这只是弥补而不是用了懒加载总体性能就提高了。
我们所说的懒加载也被称为延迟加载，它在查询的时候不会立刻访问数据库，而是返回代理对象，当真正去使用对象的时候才会访问数据库。
实现懒加载的前提:
1 实体类不能是final的
2 能实现懒加载的对象都是被CGLIB（反射调用）改写的代理对象,所以不能是final修饰的
3 须要asm,cglib两个jar包
4 相应的lazy属性为true
5 相应的fetch属性为select
下面几种可以实现懒加载功能：
1、 通过Session.load()实现懒加载
load(Object, Serializable)：根据id查询 。查询返回的是代理对象，不会立刻访问数据库，是懒加载的。当真正去使用对象的时候才会访问数据库。
用load()的时候会发现不会打印出查询语句，而使用get()的时候会打印出查询语句。
使用load()时如果在session关闭之后再查询此对象，会报异常：could not initialize proxy - no Session。处理办法：在session关闭之前初始化一下查询出来的对象：Hibernate.initialize(user);
使用load()可以提高效率，因为刚开始的时候并没有查询数据库。但很少使用。
2、 one-to-one(元素)实现了懒加载。
在一对一的时候，查询主对象时默认不是懒加载。即：查询主对象的时候也会把从对象查询出来。
需要把主对象配制成lazy="true" constrained="true" fetch="select"。此时查询主对象的时候就不会查询从对象，从而实现了懒加载。
一对一的时候，查询从对象的是默认是懒加载。即：查询从对象的时候不会把主对象查询出来。而是查询出来的是主对象的代理对象。
3、 many-to-one（元素）实现了懒加载。
多对一的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。
多对一的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。
hibernate3.0中lazy有三个值，true，false，proxy,默认的是lazy="proxy".具体设置成什么要看你的需求，并不是说哪个设置就是最好的。在<many-to-one>与<one-to-one>标签上:当为true时,会有懒加载特性,当为false时会产生N+1问题,比如一个学生对应一个班级,用一条SQL查出10个学生,当访问学生的班级属性时Hibernate会再产生10条SQL分别查出每个学生对应的班级.
lazy= 什么时候捉取
fetch= 捉取方式:select=关联查询;join=连接表的方式查询(效率高)
fetch=join时,lazy的设置将没有意义.
4、 one-to-many(元素)懒加载：默认会懒加载，这是必须的，是重常用的。
一对多的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。
一对多的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。
需要配置主对象中的set集合lazy="false" 这样就配置成是不懒加载了。或者配置抓取方式fetch="join"也可以变成不懒加载。
实现懒加载的方案:
方法一:(没有使用懒加载)
用 Hibernate.initialize(de.getEmps()) 提前加载一下.
方法二:
把与Session脱离的对象重新绑定
lock()方法是用来让应用程序把一个未修改的对象重新关联到新session的方法。
//直接重新关联
session.lock(fritz,LockMode.NONE);
//进行版本检查后关联
session.lock(izi,LockMode.READ);
//使用SELECT... FOR UPDATE进行版本检查后关联
session.lock(pk,LockMode.UPGRADE);
方法三:
OpenSessionInView
参见 http://www.javaeye.com/topic/32001
fetch 和 lazy 配置用于数据的查询
lazy 参数值常见有 false 和 true，Hibernate3映射文件中默认lazy = true ；
fetch 指定了关联对象抓取的方式，参数值常见是select和join，默认是select,select方式先查询主对象，再根据关联外键，每一个对象发一个select查询，获取关联的对象，形成了n+1次查询；而join方式，是leftouter join查询，主对象和关联对象用一句外键关联的sql同时查询出来，不会形成多次查询。
在映射文件中，不同的组合会使用不同的查询：
1、lazy="true" fetch = "select" ，使用延迟策略，开始只查询出主对象，关联对象不会查询，只有当用到的时候才会发出sql语句去查询 ；
2、lazy="false" fetch = "select" ，没有用延迟策略，同时查询出主对象和关联对象，产生1+n条sql.
3、lazy="true"或lazy="false"fetch = "join"，延迟都不会作用，因为采用的是外连接查询，同时把主对象和关联对象都查询出来了.
另 外，在hql查询中,配置文件中设置的join方式是不起作用的,而在其他查询方式如get、criteria等是有效的，使用 select方式;除非在hql中指定join fetch某个关联对象。fetch策略用于get/load一个对象时，如何获取非lazy的对象/集合。 这些参数在Query中无效。