hibernate的list和iterate的区别

一、先介绍一下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()中返回的对象是代理对象.

四、list和iterate对缓存的使用情况

1、iterate会查询session缓存、二级缓存， 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：

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<ls。size()){
    Hbtest tbo = (Hbtest)ls。get(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()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。