HIbernate——list和iterator的区别
一、先介绍一下Java中的缓存系统JCS(Java cache system)
1、JCS(java Caching System)是一个对象Cache，它可以把Java对象缓存起来，提高那些访问频率很高的Java对象的存取效率。JCS是按照对象的唯一标示来存取对象的，比如说可以按照对象的 hashCode来存取。
2、对于hibernate来说，可以利用JCS来缓存查询结果，这样当下次访问同样的数据，就无须去数据库取，直接从JCS中取出来，加快了查询速度。
3、当Hibernate使用List或者Iterator方式来第一次读取数据的时候，JCS是空的，此时不管是List方式还是Iterator方式都会往JCS里面填充查询出来的持久对象，
例如： select c from Cat as c
而 select c.id, c.name from Cat as c 这种HQL语句不构造PO，因此不会去填充JCS。
4、从JCS中区数据：
从JCS中取数据是按照对象的唯一标示来存取的，而对于PO持久对象来说，唯一标示就是主键，因此Hibernate首先必须获得主键列表，然后根据主键列表挨个判定，看这个持久对象究竟是在JCS里面还是在数据库里面，假如在JCS里面，那么按照主键取，假如在数据库，那么发送sql取。
5、这里先介绍一下Iterator可以使用JCS，而List不能。上面说了，用JCS之前，要先获得持久对象的主键，才能去JCS里面取持久对象，而获得主键列表必须去数据库中取得，这一步是没有办法缓冲的。
二、list和iterate查询数据不同形式：
1、Hibernate Iterator的查询本身是分为两步的：存在N+1问题
==> select id from cat //一条
==> select * from cat where id = ? //n条
解析：第一步，去数据库中取主键列表，第二步，按照主键一个一个取数据。假如不用JCS的话，那么从数据库中取出n条记录就需要n+1次sql查询，假如使用了JCS，他会先到JCS里面去看看，按照主键去找持久对象，假如有了，直接拿出来用，假如没有，那么只好去数据库中取得，然后再把它填到JCS里面去。
2、而Hibernate List方式：
==> select * from cat
它是JDBC的简单封装，一次sql就把所有的数据都取出来了，它不会像Iterator那样先取主键，然后再取数据，因此List无法利用JCS。不过List也可以把从数据库中取出的数据填充到JCS里面去。当再次使用list查询数据的时候，仍然要发送sql去数据库中读取数据，证明list()方法不使用缓存
三、list和iterate返回的对象分析：
list()中返回的是实体对象, 而iterate()中返回的对象是代理对象.
转载：http://blog.csdn.net/liumuqi110/article/details/4625055
四、list和iterate对缓存的使用情况
1、iterate会查询session缓存、2级缓存， list只会使用查询缓存（如果查询缓存开启的话）
2、当查询缓存开启时，对iterate和list查询语句的影响
查询缓存：将query 的cache打开的话,缓存的是query本身,以hql 生成的 sql ，再加上参数，分页等信息做为key值, 而不是query的结果.query的结果是放在session的cache中和二 级cache中,和query的cache是有区别的.
配置查询缓存：打开query的cache:1,在config中设置 hibernate.cache.use_query_cache = true,2,在创建query后query.setCacheable(true);
下面是打开query的cache后用list 的几个场景:
1:
Query q1 = s1.createQuery("from com.test.hb.Hbtest h where h.id<3");
q1.setCacheable(true);
Query q2 = s1.createQuery("from com.test.hb.Hbtest h where h.id=1");
q2.setCacheable(true);
从逻辑上将,第一个query查询出的值应该包含第二个query,但是第二个query不会用query的cache,而是会从新查询数据库.
2:
Query q1 = s1.createQuery("from com.test.hb.Hbtest h where h.id=1");
q1.setCacheable(true);
Query q2 = s1.createQuery("from com.test.hb.Hbtest h where h.id=1");
q2.setCacheable(true);
两个query一模一样,第二个query会用query的cache,不会从新查询数据库.
3:
Query q1 = s1.createQuery("from com.test.hb.Hbtest h where h.id=?").setInteger(0, 1);
q1.setCacheable(true);
Query q2 = s1.createQuery("from com.test.hb.Hbtest h where h.id=?").setInteger(0, 1);
q2.setCacheable(true);
两个query是一样的,第二个query会用query的cache,不会从新查询数据库.
4,
Query q1 = s1.createQuery("from com.test.hb.Hbtest h where h.id=?").setInteger(0, 1);
q1.setCacheable(true);
Query q2 = s1.createQuery("from com.test.hb.Hbtest h where h.id=?").setInteger(0, 2);
q2.setCacheable(true);
从逻辑上将,两个query是不一样的,第二个query不会用query的cache,而是会从新查询数据库.
query的cache打开后用iterator 的场景:
query的cache不会缓存第一次针对ID的SQL,后面iterator的时候,会根据session中的cache决定数据库的访问.可以说query的cache对iterator方式没有影响.
**如果cache的是native SQL,两个query的sql 语句必须是一样的(包括大小写).如下面的例子会访问两次数据库.
本地sql：
Query q1 = s1.createSQLQuery("select val from Hbtest H where H.id=1");
Query q2 = s1.createSQLQuery("select val from Hbtest h where h.id=1");
而对于HQL则不会,HQL会被hibernate翻译成SQL,在这过程会'识别'出是不是相同的SQL.下面的例子只访问1次数据库.
Query q1 = s1.createQuery("from com.test.hb.Hbtest h1 where h1.id=1");
Query q2 = s1.createQuery("from com.test.hb.Hbtest h where h.id=1");
五、iterate和list的使用情况：
iterate：
s1 = sessionFactory.openSession();
Query q = s1.createQuery("from com.test.hb.Hbtest h where h.id<2");
Iterator itr = q.Iterator();
while(itr.hasNext()){
Hbtest tbo = (Hbtest)itr.next();
}
list：
iterate：
s2 = sessionFactory.openSession();
Query q = s2.createQuery("from com.test.hb.Hbtest h where h.id<2");
List ls = q.list();
int i=0;
while(i
i++;
}
两者相结合的使用形式：
s1 = sessionFactory.openSession();
Query q = s1.createQuery("from com.test.hb.Hbtest h where h.id<2");
List l = q.list();
Iterator itr = l.iterator();
while(itr.hasNext()){
Hbtest tbo = (Hbtest)itr.next();
}
list()方法会一次取出所有的结果集对象，而且他会依据查询的结果初始化所有的结果集对象。如果在结果集非常庞大的时候会占据非常多的内存，甚至会造成内存溢出的情况发生。
iterator()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。
原文链接：http://www.linuxidc.com/Linux/2012-01/52003.htm