【未读】关于Hibernate缓存的使用－－（ZT－http://blog.csdn.net/woshichenxu/archive/2006/01/22/586361.aspx）

1.      关于 hibernate 缓存的问题：

1.1.1.           基本的缓存原理

Hibernate 缓存分为二级，第一级存放于 session 中称为一级缓存，默认带有且不能卸载。 <!----> <o:p> </o:p>

<o:p>   </o:p>

第二级是由 sessionFactory 控制的进程级缓存。是全局共享的缓存，凡是会调用二级缓存的查询方法 都会从中受益。只有经正确的配置后二级缓存才会发挥作用。同时在进行条件查询时必须使用相应的方法才能从缓存中获取数据。比如 Query.iterate() 方法、 load 、 get 方法等。必须注意的是 session.find 方法永远是从数据库中获取数据，不会从二级缓存中获取数据，即便其中有其所需要的数据也是如此。 <o:p> </o:p>

<o:p>   </o:p>

查询时使用缓存的实现过程为：首先查询一级缓存中是否具有需要的数据，如果没有，查询二级缓存，如果二级缓存中也没有，此时再执行查询数据库的工作。要注意的是：此 3 种方式的查询速度是依次降低的。 <o:p> </o:p>

1.2.   存在的问题

1.2.1.       一级缓存的问题以及使用二级缓存的原因

      因为 Session 的生命期往往很短，存在于 Session 内部的第一级最快缓存的生命期当然也很短，所以第一级缓存的命中率是很低的。其对系统性能的改善也是很有限的。当然，这个 Session 内部缓存的主要作用是保持 Session 内部数据状态同步。并非是 hibernate 为了大幅提高系统性能所提供的。 <o:p> </o:p>

为了提高使用 hibernate 的性能，除了常规的一些需要注意的方法比如： <o:p> </o:p>

使用延迟加载、迫切外连接、查询过滤等以外，还需要配置 hibernate 的二级缓存。其对系统整体性能的改善往往具有立竿见影的效果！ <o:p> </o:p>

（经过自己以前作项目的经验，一般会有 3~4 倍的性能提高） <o:p> </o:p>

<o:p>   </o:p>

1.2.2.       N+1 次查询的问题

执行条件查询时， iterate （）方法具有著名的 “ n+ <!----> <st1:chmetcnv w:st="on" unitname="”" sourcevalue="1" hasspace="False" negative="False" numbertype="1" tcsc="0"> 1 ” </st1:chmetcnv> 次查询的问题，也就是说在第一次查询时 iterate 方法会执行满足条件的查询结果数再加一次（ n+1 ）的查询。但是此问题只存在于第一次查询时，在后面执行相同查询时性能会得到极大的改善。此方法适合于查询数据量较大的业务数据。 <o:p> </o:p>

但是注意：当数据量特别大时（比如流水线数据等）需要针对此持久化对象配置其具体的缓存策略，比如设置其存在于缓存中的最大记录数、缓存存在的时间等参数，以避免系统将大量的数据同时装载入内存中引起内存资源的迅速耗尽，反而降低系统的性能！！！ <o:p> </o:p>

<o:p>   </o:p>

1.3.   使用 hibernate 二级缓存的其他注意事项：

1.3.1.       关于数据的有效性

另外， hibernate 会自行维护二级缓存中的数据，以保证缓存中的数据和数据库中的真实数据的一致性！ 无论何时，当你调用 save() 、 update() 或  saveOrUpdate() 方法传递一个对象时，或使用 load() 、  get() 、 list() 、 iterate()  或 scroll() 方法获得一个对象时 ,  该对象都将被加入到 Session 的内部缓存中。   当随后 flush() 方法被调用时，对象的状态会和数据库取得同步。 <o:p> </o:p>

<o:p>   </o:p>

也就是说删除、更新、增加数据的时候，同时更新缓存。当然这也包括二级缓存！ <o:p> </o:p>

<o:p>   </o:p>

只要是调用 hibernate API 执行数据库相关的工作。 hibernate 都会为你自动保证 缓存数据的有效性！！ <o:p> </o:p>

<o:p>   </o:p>

但是，如果你使用了 JDBC 绕过 hibernate 直接执行对数据库的操作。此时， Hibernate 不会 / 也不可能自行感知到数据库被进行的变化改动，也就不能再保证缓存中数据的有效性！！ <o:p> </o:p>

<o:p>   </o:p>

这也是所有的 ORM 产品共同具有的问题。幸运的是， Hibernate 为我们暴露了 Cache 的清除方法，这给我们提供了一个手动保证数据有效性的机会！！ <o:p> </o:p>

一级缓存，二级缓存都有相应的清除方法。 <o:p> </o:p>

<o:p>   </o:p>

其中二级缓存提供的清除方法为： <o:p> </o:p>

按对象 class 清空缓存 <o:p> </o:p>

                按对象 class 和对象的主键 id 清空缓存 <o:p> </o:p>

                清空对象的集合中的缓存数据等。 <o:p> </o:p>

   

1.3.2.       适合使用的情况

并非所有的情况都适合于使用二级缓存，需要根据具体情况来决定。同时可以针对某一个持久化对象配置其具体的缓存策略。 <o:p> </o:p>

<o:p>   </o:p>

适合于使用二级缓存的情况： <o:p> </o:p>

1、 数据不会被第三方修改； <o:p> </o:p>

<o:p>   </o:p>

一般情况下，会被 hibernate 以外修改的数据最好不要配置二级缓存，以免引起不一致的数据。但是如果此数据因为性能的原因需要被缓存，同时又有可能被第 3 方比如 SQL 修改，也可以为其配置二级缓存。只是此时需要在 sql 执行修改后手动调用 cache 的清除方法。以保证数据的一致性 <o:p> </o:p>

<o:p>   </o:p>

  2 、数据大小在可接收范围之内； <o:p> </o:p>

<o:p>   </o:p>

     如果数据表数据量特别巨大，此时不适合于二级缓存。原因是缓存的数据量过大可能会引起内存资源紧张，反而降低性能。 <o:p> </o:p>

<o:p>   </o:p>

如果数据表数据量特别巨大，但是经常使用的往往只是较新的那部分数据。此时，也可为其配置二级缓存。但是必须单独配置其持久化类的缓存策略，比如最大缓存数、缓存过期时间等，将这些参数降低至一个合理的范围（太高会引起内存资源紧张，太低了缓存的意义不大）。 <o:p> </o:p>

<o:p>   </o:p>

  3 、数据更新频率低； <o:p> </o:p>

<o:p>   </o:p>

     对于数据更新频率过高的数据，频繁同步缓存中数据的代价可能和 查询缓存中的数据从中获得的好处相当，坏处益处相抵消。此时缓存的意义也不大。 <o:p> </o:p>

<o:p>   </o:p>

<o:p>   </o:p>

  4 、非关键数据（不是财务数据等） <o:p> </o:p>

<o:p>   </o:p>

  财务数据等是非常重要的数据，绝对不允许出现或使用无效的数据，所以此时为了安全起见最好不要使用二级缓存。 <o:p> </o:p>

  因为此时 “正确性”的重要性远远大于 “高性能”的重要性。 <o:p> </o:p>

<o:p>   </o:p>

2.      目前系统中使用 hibernate 缓存的建议

1.4.   目前情况

 一般系统中有三种情况会绕开hibernate执行数据库 操作：

<o:p> 1、多个应用系统同时访问一个数据库 </o:p>

<o:p>    此种情况使用hibernate二级缓存会不可避免的造成数据不一致的问题， </o:p>

<o:p>    此时要进行 </o:p> <o:p> 详细的设计。比如在设计上避免对同一数据表的同时的写入操作， </o:p>

<o:p>    使用数据库各种级别的锁定机制等。 </o:p>

<o:p>   </o:p>

2 、动态表相关

   所谓“动态表”是指在系统运行时根据用户的操作系统自动建立的数据表。

   比如“自定义表单”等属于用户自定义扩展开发性质的功能模块，因为此时数据表是运行时建立的，所以不能进行hibernate的映射。因此对它的操作只能是绕开hibernate的直接数据库JDBC操作。

        如果此时动态表中的数据没有设计缓存，就不存在数据不一致的问题。

   如果此时自行设计了缓存机制，则调用自己的缓存同步方法即可。

<o:p> </o:p>

3 、使用 sql对hibernate持久化对象表 进行批量删除时

     此时 执行批量删除后，缓存中会存在已被删除的数据。 <o:p> </o:p>

<o:p> 分析：  </o:p>

   当执行了第3条（ sql 批量删除）后，后续的查询只可能是以下三种方式： <o:p> </o:p>

a. session.find （）方法： <o:p> </o:p>

根据前面的总结， find 方法不会查询二级缓存的数据，而是直接查询数据库。 <o:p> </o:p>

所以不存在数据有效性的问题。 <o:p> </o:p>

b. 调用 iterate 方法执行条件查询时： <o:p> </o:p>

根据 iterate 查询方法的执行方式，其每次都会到数据库中查询满足条件的 id 值，然后再根据此 id 到缓存中获取数据，当缓存中没有此 id 的数据才会执行数据库查询； <o:p> </o:p>

如果此记录已被 sql 直接删除，则 iterate 在执行 id 查询时不会将此 id 查询出来。所以，即便缓存中有此条记录也不会被客户获得，也就不存在不一致的情况。（此情况经过测试验证） <o:p> </o:p>

<o:p>   </o:p>

c. 用 get 或 load 方法按 id 执行查询： <o:p> </o:p>

<o:p>   </o:p>

客观上此时会查询得到已过期的数据。但是又因为系统中执行sql批量删除一般是

针对中间关联数据表，对于

中间关联表的查询一般都是采用条件查询 , 按 id 来查询某一条关联关系的几率很低 , 所以此问题也不存在 !<o:p></o:p>

<o:p>   </o:p>

      如果某个值对象确实需要按 id 查询一条关联关系 , 同时又因为数据量大使用 了 sql 执行批量删除。当满足此两个条件时 , 为了保证按 id 的查询得到正确的结果 , 可以使用手动清楚二级缓存中此对象的数据的方法 !!<o:p></o:p>

( 此种情况出现的可能性较小 )<o:p></o:p>

<o:p>   </o:p>

1.5.   建议

1 、建议不要使用 sql 直接执行数据持久化对象的数据的更新，但是可以执行 批量删除。（系统中需要批量更新的地方也较少） <o:p> </o:p>

<o:p>   </o:p>

2 、如果必须使用 sql 执行数据的更新，必须清空此对象的缓存数据。调用 <o:p> </o:p>

SessionFactory.evict(class) <o:p></o:p>

SessionFactory.evict(class,id)<o:p></o:p>

等方法。 <o:p> </o:p>

<o:p>   </o:p>

3 、在批量删除数据量不大的时候可以直接采用 hibernate 的批量删除，这样就不存在绕开 hibernate 执行 sql 产生的缓存数据一致性的问题。 <o:p> </o:p>

<o:p>   </o:p>

4 、不推荐采用 hibernate 的批量删除方法来删除大批量的记录数据。 <o:p> </o:p>

原因是 hibernate 的批量删除会执行 1 条查询语句外加 满足条件的 n 条删除语句。而不是一次执行一条条件删除语句！！ <o:p> </o:p>

当待删除的数据很多时会有很大的性能瓶颈！！！如果批量删除数据量较大 , 比如超过 50 条 , 可以采用 JDBC 直接删除。这样作的好处是只执行一条 sql 删除语句 , 性能会有很大的改善。同时，缓存数据同步的问题 , 可以采用 hibernate 清除二级缓存中的相关数据的方法。 <o:p> </o:p>

调用 SessionFactory.evict(class) ； SessionFactory.evict(class,id) 等方法。 <o:p> </o:p>

<o:p>   </o:p>

所以说，对于一般的应用系统开发而言（不涉及到集群，分布式数据同步问题等），因为只在中间关联表执行批量删除时调用了 sql 执行，同时中间关联表一般是执行条件查询不太可能执行按 id 查询。所以，此时可以直接执行 sql 删除，甚至不需要调用缓存的清除方法。这样做不会导致以后配置了二级缓存引起数据有效性的问题。 <o:p> </o:p>

<o:p>   </o:p>

退一步说，即使以后真的调用了按 id 查询中间表对象的方法，也可以通过调用清除缓存的方法来解决。

<o:p> </o:p>  

<o:p> </o:p> 4、具体的配置方法 

根据我了解的很多hibernate的使用者在调用其相应方法时都迷信的相信“hibernate会自行为我们处理性能的问题”，或者“hibernate 会自动为我们的所有操作调用缓存”,实际的情况是hibernate虽然为我们提供了很好的缓存机制和扩展缓存框架的支持，但是必须经过正确的调用其才有可能发挥作用！！所以造成很多使用hibernate的系统的性能问题，实际上并不是hibernate不行或者不好，而是因为使用者没有正确的了解其使用方法造成的。相反，如果配置得当hibernate的性能表现会让你有相当“惊喜的”发现。下面我讲解具体的配置方法.

 ibernate提供了二级缓存的接口：
net.sf.hibernate.cache.Provider,
同时提供了一个默认的 实现net.sf.hibernate.cache.HashtableCacheProvider，
也可以配置 其他的实现 比如ehcache,jbosscache等。

具体的配置位置位于hibernate.cfg.xml文件中
<property name="hibernate.cache.use_query_cache">true</property>
<property name="hibernate.cache.provider_class">net.sf.hibernate.cache.HashtableCacheProvider</property>

很多的hibernate使用者在 配置到 这一步 就以为 完事了，
注意：其实光这样配，根本就没有使用hibernate的二级缓存。同时因为他们在使用hibernate时大多时候是马上关闭session，所以，一级缓存也没有起到任何作用。结果就是没有使用任何缓存，所有的hibernate操作都是直接操作的数据库！！性能可以想见。

正确的办法是除了以上的配置外还应该配置每一个vo对象的具体缓存策略，在影射文件中配置。例如：

<hibernate-mapping>
<class name="com.sobey.sbm.model.entitySystem.vo.DataTypeVO" table="dcm_datatype">
<cache usage="read-write"/>
<id name="id" column="TYPEID" type="java.lang.Long">
<generator class="sequence"/>
</id>

<property name="name" column="NAME" type="java.lang.String"/>
<property name="dbType" column="DBTYPE" type="java.lang.String"/>
</class>
</hibernate-mapping>

关键就是这个<cache usage="read-write"/>，其有几个选择
read-only,read-write,transactional,等
然后在执行查询时 注意了 ，如果是条件查询，或者返回所有结果的查询，此时session.find()方法 不会获取缓存中的数据。只有调用query.iterate()方法时才会调缓存的数据。

同时 get 和 load方法 是都会查询缓存中的数据 .

对于不同的缓存框架具体的配置方法会有不同，但是大体是以上的配置

（另外，对于支持事务型，以及支持集群的环境的配置我会争取在后续的文章中中 发表出来）

 

3.      总结

总之是根据不同的业务情况和项目情况对 hibernate 进行有效的配置和正确的使用，扬长避短。不存在适合于任何情况的一个“万能”的方案。 <o:p> </o:p>

以上结论及建议均建立在自己在对 Hibernate <st1:chsdate w:st="on" year="1899" month="12" day="30" islunardate="False" isrocdate="False">2.1.2</st1:chsdate> 中的测试结果以及以前的项目经验的基础上。如有谬处，请打家提出指正:)!

最后，祝大家 新年快乐！！在新的一年里 取得人生的进步！！！