Hibernate是基于缓存机制实现的。Hibernate的缓存包括：一级缓存、二级缓存和查询缓存。
Hibernate中支持懒加载load，也支持及时加载get。Hibernate采用CGlib的动态代理实现延迟加载。延迟加载采用CGlib的Enhancer类动态生成类。
下面对Hibernate中一级缓存、二级缓存、查询缓存机制做一个横向比较：
相同点：
1、均为缓存，均可在一定的条件下缓存数据；
2、Hibernate的查询实现，是基于缓存机制；
3、三种缓存方式的内部实现方式类似，均使用key-value的map键值对方式实现；
4、一级缓存与二级缓存，军师对实体对象的缓存。内部实现均是：key里面放的是对象主键Id，value里面放的是实体对象。所以它们是实体对象的缓存。
不同点：
1、一级缓存，又称Session缓存，或者事务级缓存，它是内置的，不能被卸载。由于Session对象的生命周期通常对应一个数据库事务或一个应用事务，所以它的缓存是事务范围的缓存；
2、二级缓存，又称为SessionFactory缓存，它是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发策略，该策略为被缓存的数据提供了事务隔离级别；
3、查询缓存，是普通属性的缓存。查询缓存的生命周期：当关联的表发生修改，查询缓存的生命周期结束；
4、一级缓存是进程级的，进程结束后，即Session关闭后，缓存也随之清空；二级缓存与查询缓存均与Session无关，二级缓存的生命周期可以根据策略手动配置；查询缓存的生命周期与相关联的表相关；
5、一级缓存的存活期比较短，所以命中率比较低；查询缓存当关联表数据变更时，缓存生命周期结束，故命中率也比较低；二级缓存存活期较长，实际项目中应用也比较多；
6、一级缓存并不是为了大幅度提高性能而设置的，Hibernate主要使用一级缓存进行数据同步；而二级缓存的使用，由于它是进程范围内的缓存，可以大幅度提高性能。而查询缓存是为了缓存普通属性设置的缓存。
各种举例
拿公司和员工来举例子：
一、同一个session中，发生两次Load查询
在同一个session中，发出两次load查询。第一次查询，locad时查询代理，不查询上来数据，执行方法时，执行语句；
第二次查询，将不会再发出sql语句，直接在一级缓存里面取得。
二、同一个session中，发生两次get查询
在同一个session中，发出两次get查询。第一次查询，get时查询，马上执行查询语句，查询上来数据，方法执行时不再发sql语句。同时，将该数据放入缓存中。
第二次查询时，不会再发出sql语句，直接从缓存里面取得，除非第二次查询时，数据发生了变化。它与load一样，缓存中有的话，将直接查询。
三、同一个session中，发出两次iterate查询，查询实体对象
同一个session中，发出两次iterate查询，查询实体对象
第一次查询，发生N+1问题。第一次是查询所有id，然后去缓存里面去找，因为是第一次查询，缓存里面没有数据；所以会根据id，去数据库里面再次查询n次。
第二次查询，它会发出查询id语句，然后直接去缓存里面取得。
四、同一个session中，发出两次iterate查询，查询普通属性
同一个session中，发出两次iterate查询，查询普通属性。
这时，它还是会把sql语句发出来。
这是因为，iterate查询普通属性，一级缓存不会缓存，一级缓存只缓存实体对象查询。普通属性查询，不会缓存。
一级缓存是缓存实体对象的
五、在两个session里面，发load查询
在两个session里面，发load查询
由于session是进程级缓存，一个线程对应一个session，所以第一次查询后，会关闭session
第二次再次开启session
session间不能缓存一级缓存数据。因为它会伴随着session的消亡，而消亡。
所以会发两条语句
六、在同一个session中，先调用save，在调用load查询刚刚save的数据
在同一个session中，先调用save，在调用load查询刚刚save的数据
save也是支持缓存的。save之后，它会先往缓存里面存一份，取得时候，直接在缓存里面取
查询时，不会发出sql语句，因为save支持缓存。
七、大批量数据添加
大批量数据添加
对于大批量的数据添加，我们采用下面的做法：
每二十条数据，清一下缓存，到数据库里面存一次。最后提交事务
二级缓存，是SessionFactory级别的，因为SessionFactory能够管理它。二级缓存可以被所有的session共享。二级缓存，默认不启动，一般需要使用第三方产品。
使用ehcache第三方产品支持Hibernate的缓存。
<ehcache>
<diskStore path="java.io.tmpdir"/> <!--超出部分保存的位置-->
<defaultCache
maxElementsInMemory="10000" <!--缺省配置，可以防止一万个对象-->
eternal="false" <!--过不过期，true时，永远不过期-->
timeToIdleSeconds="120" <!--第一次访问后，间隔120秒没被访问，就清掉缓存-->
timeToLiveSeconds="120" <!--缓存能够存活的时间120秒-->
overflowToDisk="true" <!--溢出的问题，如果已经超出了1万个对象，设置为TRUE，就保存在磁盘上-->
/>
</ehcache>
一、开启二级缓存，开启两个session，执行两次load方法
第一次load使用时，执行sql语句；第二次执行load时，不发语句。
因为它先到一级缓存里面找，没有数据，然后再去二级缓存里面找，查找到数据。
session可以共享二级缓存中的数据；二级缓存是进程级的。
二、开启二级缓存，开启两个session，执行两次get方法
与load基本类似，第一次查询发语句，第二次查询查询二级缓存。
三、开启二级缓存，在两个session中发load查询,采用SessionFactory管理二级缓存
//删除二级缓存
//HibernateUtils.getSessionFactory().evict(Student.class);
HibernateUtils.getSessionFactory().evict(Student.class, 1);
第二次查询时：会发出查询语句，因为二级缓存中的数据被清除了
四、开启二级缓存 ，一级缓存和二级缓存的交互
//禁止将一级缓存中的数据放到二级缓存中
session.setCacheMode(CacheMode.IGNORE);
第二次查询时：会发出查询语句，因为禁止了一级缓存和二级缓存的交互
五、 大批量的数据添加
大批量数据交互时，禁止一级缓存与二级缓存的交互，同时每二十条清一下一级缓存。
总结：二级缓存与一级缓存一模一样，只缓存实体对象，不缓存普通属性。
查询缓存是缓存普通属性的结果集
对实体对象的结果集缓存会缓存Id，生命周期不定。当表里的数据发生变化，查询缓存的生命周期结束。
查询缓存的配置和使用：
修改hibernate.cfg.xml文件，来开启查询缓存，默认是false,是不起用的
<property name="hibernate.cache.use_query_cache">true</property>
//必须在程序启用
query.setCacheable(true)
一、开启查询，关闭二级缓存，采用query.list()查询普通属性
在一个session中发query.list()查询
//执行两次如下代码
List names = session.createQuery("select s.name from Student s")
.setCacheable(true)
.list();
第一次将发出sql语句，第二次不发语句
二、 开启查询，关闭二级缓存，采用query.list()查询普通属性
在两个session中发query.list()查询
执行结果如上，跨session。查询缓存与session没关系
三、开启查询，关闭二级缓存，采用query.iterate()查询普通属性
在两个session中发query.iterate()查询
第二次查询会发出sql语句，
会发出查询语句，query.iterate()查询普通属性它不会使用查询缓存
查询缓存只对query.list()起作用
四、关闭查询，关闭二级缓存，采用query.list()查询实体
在两个session中发query.list()查询
会发出查询语句，默认query.list()每次执行都会发出查询语句
五、开启查询，关闭二级缓存，采用query.list()查询实体在两个session中发query.list()查询
会发出n条查询语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存就会缓存实体对象的id
第二次执行query.list(),将查询缓存中的id依次取出，分别到一级缓存和二级缓存中查询相应的实体
对象,如果存在就使用缓存中的实体对象，否则根据id发出查询学生的语句
六、开启查询，开启二级缓存，采用query.list()查询实体
在两个session中发query.list()查询
不再发出查询语句，因为配置了二级缓存和查询缓存
其他
1、加载方式
Hibernate有四种加载方式：即时加载、延迟加载、预先加载和批量加载。
a、即时加载
实体加载完成后，立即加载与实体先关连的数据，并填充到实体对应的属性中。这种加载方式通常会发多条sql语句；
b、延迟加载
实体加载时，其关联数据并不是立即读取，而是当关联数据第一次被访问再进行读取。这种加载方式在第一次访问关联数据时，必须在同一个session中，否则包session关闭的错误；
这种方式内部是采用动态代理实现的，具体内容请参见Spring AOP一文。
c、预先加载
预先加载是发出“outer-join”语句。可以通过全局变量Hibernate.max_fetch_depth限定join的层次
d、批量加载
对于及时加载和延迟加载，可以采用批量价在进行优化。
批量价在通过批量提交多个限制条件，一次多个限定条件的数据读取。同时在实体映射文件中的class节点，通过配置batch-size参数打开批量加载机制，并限定每次批量加载数据的数量。
2、缓存机制导致的问题
Hibernate的缓存机制，导致了一些问题：a、n+1问题；b、OpenSessionInView
a、n+1问题
n+1问题就是在迭代查询时，发出了n+1条语句，如：
Iterator iter = session.createQuery("from User").list();
执行上面这段代码，直接返回一个迭代器。这时，假设一共有n条数据，那么它会执行n+1条sql语句。
这是因为：首先，它会把所有的主键Id查询上来，然后根据Id，去缓存里面找，也就是session里面找。如果缓存中已经有的数据的话，则它会直接从缓存里面取；如果缓存里面没有数据，则它需要根据Id，一条一条去数据库里面查询。所以会发出n+1条语句。
如何避免n+1问题？
可以先返回List：
List users = session.createQuery("from User").list();
该查询，会将查询上来的数据保存在缓存里面，也就是一级缓存里面。这是我们不关闭session，使用同一个session，进行迭代查询。
Iterator iter = session.createQuery("from User").list();
这时，它会发送一条查询Id的sql语句，然后再去一级缓存里面找，因为缓存里面都有数据，所以会直接查询上来。
注意：List查询时，不查询缓存；Iterator查询，会查询缓存。
b、OpenSessionInView
Hibernate查询中采用懒加载时，即设置了lazy=true，那么读取数据的时候，当读取了父数据后，进程结束。Hibernate会自动关系Session，这样，当要使用子数据的时候，系统会找不到当前session，所以，这就需要保持session一直开着，直到调用调用结束为止。
这个好办，只需要在发出请求之初，开启session时，将开启的session放入Threadlocal中，结束后再在Threadlocal中结束该进程。这个过程就是OpensessionInView的过程。
总结
1、一级缓存与二级缓存的最大区别就是：一级缓存是Session级缓存；二级缓存是跨Session的缓存。其他机制完全类似。
2、二级缓存是Session间的，能够跨Session；
3、查询缓存是Session间的，能够跨Session；
4、query.iterate()查询普通属性不会使用查询缓存，查询缓存只对query.list()起作用；
5、一级缓存生命周期很短暂，故命中率不高；查询缓存的生命周期与相关联表有关。关联表数据有变动，查询缓存的生命周期结束；二级缓存的生命周期可以认为控制，利用率较大。
原文地址：http://blog.csdn.net/liu765023051/article/details/40263621
