hibernate缓存清除缓存

① 怎样解决hibernate中一级缓存导致数据不能刷新

Hibernate的一级缓存是由Session提供的，因此它只存在于Session的生命周期中，也就是当Session关闭的时候该Session所管理的一级缓存也会立即被清除。

Hibernate的一级缓存是Session所内置的，不能被卸载，也不能进行任何配置。

一级缓存采用的是key-value的Map方式来实现的，在缓存实体对象时，对象的主关键字ID是Map的key，实体对象就是对应的值。所以说，一级缓存是以实体对象为单位进行存储的，在访问的时候使用的是主关键字ID。

虽然，Hibernate对一级缓存使用的是自动维护的功能，没有提供任何配置功能，但是可以通过Session中所提供的方法来对一级缓存的管理进行手工干预。Session中所提供的干预方法包括以下两种。

evict() ：用于将某个对象从Session的一级缓存中清除。

clear() ：用于将一级缓存中的对象全部清除。

在进行大批量数据一次性更新的时候，会占用非常多的内存来缓存被更新的对象。这时就应该阶段性地调用clear()方法来清空一级缓存中的对象，控制一级缓存的大小，以避免产生内存溢出的情况。

② hibernate二级缓存什么时候用

Hibernate缓存何时使用和如何使用？

Hibernate缓存分为二级，第一级存放于session中称为一级缓存，默认带有且不能卸载。第二级是由sessionFactory控制的进程级缓存。是全局共享的缓存，凡是会调用二级缓存的查询方法 都会从中受益。

1. 关于hibernate缓存的问题：

1.1. 基本的缓存原理

Hibernate缓存分为二级，

第一级存放于session中称为一级缓存，默认带有且不能卸载。

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

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

1.2. 存在的问题

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

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

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

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

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

1.2.2. N+1次查询的问题

1.2.2.1 什么时候会遇到1+N的问题？

前提：Hibernate默认表与表的关联方法是fetch="select"，不是fetch="join",这都是为了懒加载而准备的。

1）一对多(<set><list>) ，在1的这方，通过1条sql查找得到了1个对象，由于关联的存在 ，那么又需要将这个对象关联的集合取出，所以合集数量是n还要发出n条sql，于是本来的1条sql查询变成了1 +n条 。

2）多对一<many-to-one> ，在多的这方，通过1条sql查询得到了n个对象，由于关联的存在,也会将这n个对象对应的1 方的对象取出， 于是本来的1条sql查询变成了1 +n条 。

3）iterator 查询时,一定先去缓存中找（1条sql查集合,只查出ID），在没命中时，会再按ID到库中逐一查找， 产生1+n条SQL

1.2.2.2 怎么解决1+N 问题？

1 ）lazy=true， hibernate3开始已经默认是lazy=true了；lazy=true时不会立刻查询关联对象，只有当需要关联对象（访问其属性，非id字段）时才会发生查询动作。

2）使用二级缓存， 二级缓存的应用将不怕1+N 问题，因为即使第一次查询很慢（未命中），以后查询直接缓存命中也是很快的。刚好又利用了1+N 。

3) 当然你也可以设定fetch="join"，一次关联表全查出来，但失去了懒加载的特性。

执行条件查询时，iterate（）方法具有着名的 “n+1”次查询的问题，也就是说在第一次查询时iterate方法会执行满足条件的查询结果数再加一次（n+1）的查询。但是此问题只存在于第一次查询 时，在后面执行相同查询时性能会得到极大的改善。此方法适合于查询数据量较大的业务数据。

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

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

1.3.1. 关于数据的有效性

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

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

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

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

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

一级缓存，二级缓存都有相应的清除方法。

其中二级缓存提供的清除方法为：

按对象class清空缓存

按对象class和对象的主键id清空缓存

清空对象的集合中的缓存数据等。

1.3.2. 适合使用的情况

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

适合于使用二级缓存的情况：

1、数据不会被第三方修改；

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

2、数据大小在可接收范围之内；

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

3、数据更新频率低；

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

4、非关键数据（不是财务数据等）

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

因为此时 “正确性”的重要性远远大于 “高性能”的重要性。

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

2.1. 目前情况

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

1、多个应用系统同时访问一个数据库

此种情况使用hibernate二级缓存会不可避免的造成数据不一致的问题，此时要进行详细的设计。比如在设计上避免对同一数据表的同时的写入操作，
使用数据库各种级别的锁定机制等。

2、动态表相关

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

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

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

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

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

此时执行批量删除后，缓存中会存在已被删除的数据。

分析：

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

a. session.find（）方法：

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

所以不存在数据有效性的问题。

b. 调用iterate方法执行条件查询时：

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

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

c. 用get或load方法按id执行查询：

客观上此时会查询得到已过期的数据。但是又因为系统中执行sql批量删除一般是针对中间关联数据表，对于中间关联表的查询一般都是采用条件查询 ,按id来查询某一条关联关系的几率很低,所以此问题也不存在!

如果某个值对象确实需要按id查询一条关联关系,同时又因为数据量大使用 了sql执行批量删除。当满足此两个条件时,为了保证按id 的查询得到正确的结果,可以使用手动清楚二级缓存中此对象的数据的方法!!(此种情况出现的可能性较小)

2.2. 建 议

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

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

SessionFactory.evict(class)

SessionFactory.evict(class,id)等方法。

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

4、不推荐采用hibernate的批量删除方法来删除大批量的记录数据。

原因是hibernate的批量删除会执行1条查询语句外加 满足条件的n条删除语句。而不是一次执行一条条件删除语句！！
当待删除的数据很多时会有很大的性能瓶颈！！！如果批量删除数据量较大,比如超过50条,可以采用JDBC直接删除。这样作的好处是只执行一条sql删除语句,性能会有很大的改善。同时，缓存数据同步的问题,可以采用 hibernate清除二级缓存中的相关数据的方法。

调 用

SessionFactory.evict(class) ;

SessionFactory.evict(class,id)等方法。

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

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

3、具体的配置方法

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

ibernate提供了二级缓存的接口：

net.sf.hibernate.cache.Provider,

同时提供了一个默认的 实现net.sf.hibernate.cache.HashtableCacheProvider，

也可以配置 其他的实现 比如ehcache,jbosscache等。

具体的配置位置位于hibernate.cfg.xml文件中

• <propertyname="hibernate.cache.use_query_cache">true</property>

• <propertyname="hibernate.cache.provider_class">net.sf.hibernate.cache.HashtableCacheProvider</property>

很多的hibernate使用者在 配置到 这一步 就以为 完事了，

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

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

• <hibernate-mapping>

• <classname="com.sobey.sbm.model.entitySystem.vo.DataTypeVO"table="dcm_datatype">

• <cacheusage="read-write"/>

• <idname="id"column="TYPEID"type="java.lang.Long">

• <generatorclass="sequence"/>

• </id>

• <propertyname="name"column="NAME"type="java.lang.String"/>

• <propertyname="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方法 是都会查询缓存中的数据

③ hibernate怎么清除查询出来的缓存数据

下面我们分析一下几种方法： 1 clear()方法 我们可以在session-factory标签下创建property标签，name属性为hibernate.jdbc.batch_size,值为我们想要设定的数字，假如为100，下一步当我们执行操作flush()发送SQL语句时候调用session.clear()方法，就可以实现清除缓存的效果了。 for(int i=0;i<1000;i++){ Order order = new Order(); order.setId(); session.save(order); if(i%100==0){ session.flush(); session.clear(); } } 2 evict()方法 该方法于上一个方法不同，它只能用于处理单个对象的清除工作。 for(int i=0;i<1000;i++){ Order order = new Order(); order.setI ... 在网上找的 不知对不对 追问： 这个方法我看到了，没起作用~！

④ hibernate缓存的详细配置

很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。
我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。

hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。

二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等，需要设置hibernate.cache.provider_class，我们这里用ehcache，在2.1中就是
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
如果使用查询缓存，加上
hibernate.cache.use_query_cache=true

缓存可以简单的看成一个Map，通过key在缓存里面找value。

Class的缓存
对于一条记录，也就是一个PO来说，是根据ID来找的，缓存的key就是ID，value是POJO。无论list，load还是iterate，只要读出一个对象，都会填充缓存。但是list不会使用缓存，而iterate会先取数据库select id出来，然后一个id一个id的load，如果在缓存里面有，就从缓存取，没有的话就去数据库load。假设是读写缓存，需要设置：
<cache usage="read-write"/>
如果你使用的二级缓存实现是ehcache的话，需要配置ehcache.xml
<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
其中eternal表示缓存是不是永远不超时，timeToLiveSeconds是缓存中每个元素（这里也就是一个POJO）的超时时间，如果eternal="false"，超过指定的时间，这个元素就被移走了。timeToIdleSeconds是发呆时间，是可选的。当往缓存里面put的元素超过500个时，如果overflowToDisk="true"，就会把缓存中的部分数据保存在硬盘上的临时文件里面。
每个需要缓存的class都要这样配置。如果你没有配置，hibernate会在启动的时候警告你，然后使用defaultCache的配置，这样多个class会共享一个配置。
当某个ID通过hibernate修改时，hibernate会知道，于是移除缓存。
这样大家可能会想，同样的查询条件，第一次先list，第二次再iterate，就可以使用到缓存了。实际上这是很难的，因为你无法判断什么时候是第一次，而且每次查询的条件通常是不一样的，假如数据库里面有100条记录，id从1到100，第一次list的时候出了前50个id，第二次iterate的时候却查询到30至70号id，那么30-50是从缓存里面取的，51到70是从数据库取的，共发送1+20条sql。所以我一直认为iterate没有什么用，总是会有1+N的问题。
（题外话：有说法说大型查询用list会把整个结果集装入内存，很慢，而iterate只select id比较好，但是大型查询总是要分页查的，谁也不会真的把整个结果集装进来，假如一页20条的话，iterate共需要执行21条语句，list虽然选择若干字段，比iterate第一条select id语句慢一些，但只有一条语句，不装入整个结果集hibernate还会根据数据库方言做优化，比如使用mysql的limit，整体看来应该还是list快。）
如果想要对list或者iterate查询的结果缓存，就要用到查询缓存了

查询缓存
首先需要配置hibernate.cache.use_query_cache=true
如果用ehcache，配置ehcache.xml，注意hibernate3.0以后不是net.sf的包名了
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
然后
query.setCacheable(true);//激活查询缓存
query.setCacheRegion("myCacheRegion");//指定要使用的cacheRegion，可选
第二行指定要使用的cacheRegion是myCacheRegion，即你可以给每个查询缓存做一个单独的配置，使用setCacheRegion来做这个指定，需要在ehcache.xml里面配置它：
<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />
如果省略第二行，不设置cacheRegion的话，那么会使用上面提到的标准查询缓存的配置，也就是net.sf.hibernate.cache.StandardQueryCache

对于查询缓存来说，缓存的key是根据hql生成的sql，再加上参数，分页等信息（可以通过日志输出看到，不过它的输出不是很可读，最好改一下它的代码）。
比如hql：
from Cat c where c.name like ?
生成大致如下的sql：
select * from cat c where c.name like ?
参数是"tiger%"，那么查询缓存的key*大约*是这样的字符串（我是凭记忆写的，并不精确，不过看了也该明白了）：
select * from cat c where c.name like ? , parameter:tiger%
这样，保证了同样的查询、同样的参数等条件下具有一样的key。
现在说说缓存的value，如果是list方式的话，value在这里并不是整个结果集，而是查询出来的这一串ID。也就是说，不管是list方法还是iterate方法，第一次查询的时候，它们的查询方式很它们平时的方式是一样的，list执行一条sql，iterate执行1+N条，多出来的行为是它们填充了缓存。但是到同样条件第二次查询的时候，就都和iterate的行为一样了，根据缓存的key去缓存里面查到了value，value是一串id，然后在到class的缓存里面去一个一个的load出来。这样做是为了节约内存。
可以看出来，查询缓存需要打开相关类的class缓存。list和iterate方法第一次执行的时候，都是既填充查询缓存又填充class缓存的。
这里还有一个很容易被忽视的重要问题，即打开查询缓存以后，即使是list方法也可能遇到1+N的问题！相同条件第一次list的时候，因为查询缓存中找不到，不管class缓存是否存在数据，总是发送一条sql语句到数据库获取全部数据，然后填充查询缓存和class缓存。但是第二次执行的时候，问题就来了，如果你的class缓存的超时时间比较短，现在class缓存都超时了，但是查询缓存还在，那么list方法在获取id串以后，将会一个一个去数据库load！因此，class缓存的超时时间一定不能短于查询缓存设置的超时时间！如果还设置了发呆时间的话，保证class缓存的发呆时间也大于查询的缓存的生存时间。这里还有其他情况，比如class缓存被程序强制evict了，这种情况就请自己注意了。

另外，如果hql查询包含select字句，那么查询缓存里面的value就是整个结果集了。

当hibernate更新数据库的时候，它怎么知道更新哪些查询缓存呢？
hibernate在一个地方维护每个表的最后更新时间，其实也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的缓存配置里面。
当通过hibernate更新的时候，hibernate会知道这次更新影响了哪些表。然后它更新这些表的最后更新时间。每个缓存都有一个生成时间和这个缓存所查询的表，当hibernate查询一个缓存是否存在的时候，如果缓存存在，它还要取出缓存的生成时间和这个缓存所查询的表，然后去查找这些表的最后更新时间，如果有一个表在生成时间后更新过了，那么这个缓存是无效的。
可以看出，只要更新过一个表，那么凡是涉及到这个表的查询缓存就失效了，因此查询缓存的命中率可能会比较低。

Collection缓存
需要在hbm的collection里面设置
<cache usage="read-write"/>
假如class是Cat，collection叫children，那么ehcache里面配置
<cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" />
Collection的缓存和前面查询缓存的list一样，也是只保持一串id，但它不会因为这个表更新过就失效，一个collection缓存仅在这个collection里面的元素有增删时才失效。
这样有一个问题，如果你的collection是根据某个字段排序的，当其中一个元素更新了该字段时，导致顺序改变时，collection缓存里面的顺序没有做更新。

缓存策略
只读缓存（read-only）：没有什么好说的
读/写缓存（read-write）:程序可能要的更新数据
不严格的读/写缓存（nonstrict-read-write）：需要更新数据，但是两个事务更新同一条记录的可能性很小，性能比读写缓存好
事务缓存（transactional）：缓存支持事务，发生异常的时候，缓存也能够回滚，只支持jta环境，这个我没有怎么研究过

读写缓存和不严格读写缓存在实现上的区别在于，读写缓存更新缓存的时候会把缓存里面的数据换成一个锁，其他事务如果去取相应的缓存数据，发现被锁住了，然后就直接取数据库查询。
在hibernate2.1的ehcache实现中，如果锁住部分缓存的事务发生了异常，那么缓存会一直被锁住，直到60秒后超时。
不严格读写缓存不锁定缓存中的数据。

使用二级缓存的前置条件
你的hibernate程序对数据库有独占的写访问权，其他的进程更新了数据库，hibernate是不可能知道的。你操作数据库必需直接通过hibernate，如果你调用存储过程，或者自己使用jdbc更新数据库，hibernate也是不知道的。hibernate3.0的大批量更新和删除是不更新二级缓存的，但是据说3.1已经解决了这个问题。
这个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧。
SessionFactory也提供了移除缓存的方法，你一定要自己写一些JDBC的话，可以调用这些方法移除缓存，这些方法是：
void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.
不过我不建议这样做，因为这样很难维护。比如你现在用JDBC批量更新了某个表，有3个查询缓存会用到这个表，用evictQueries(String cacheRegion)移除了3个查询缓存，然后用evict(Class persistentClass)移除了class缓存，看上去好像完整了。不过哪天你添加了一个相关查询缓存，可能会忘记更新这里的移除代码。如果你的jdbc代码到处都是，在你添加一个查询缓存的时候，还知道其他什么地方也要做相应的改动吗？

----------------------------------------------------

总结：
不要想当然的以为缓存一定能提高性能，仅仅在你能够驾驭它并且条件合适的情况下才是这样的。hibernate的二级缓存限制还是比较多的，不方便用jdbc可能会大大的降低更新性能。在不了解原理的情况下乱用，可能会有1+N的问题。不当的使用还可能导致读出脏数据。
如果受不了hibernate的诸多限制，那么还是自己在应用程序的层面上做缓存吧。
在越高的层面上做缓存，效果就会越好。就好像尽管磁盘有缓存，数据库还是要实现自己的缓存，尽管数据库有缓存，咱们的应用程序还是要做缓存。因为底层的缓存它并不知道高层要用这些数据干什么，只能做的比较通用，而高层可以有针对性的实现缓存，所以在更高的级别上做缓存，效果也要好些吧。

⑤ Hibernate缓存何时使用和如何使用

关于hibernate缓存的问题

基本的缓存原理

Hibernate缓存分为二级

第一级存放于session中称为一级缓存 默认带有且不能卸载

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

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

存在的问题

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

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

为了提高使用hibernate的性能 除了常规的一些需要注意的方法比如

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

（经过自己以前作项目的经验 一般会有 ~ 倍的性能提高）

N+ 次查询的问题

什么时候会遇到 +N的问题？

前提 Hibernate默认表与表的关联方法是fetch= select 不是fetch= join 这都是为了懒加载而准备的

）一对多(<set><list>) 在 的这方 通过 条sql查找得到了 个对象 由于关联的存在 那么又需要将这个对象关联的集合取出 所以合集数量是n还要发出n条sql 于是本来的 条sql查询变成了 +n条

）多对一<many to one> 在多的这方 通过 条sql查询得到了n个对象 由于关联的存在 也会将这n个对象对应的 方的对象取出 于是本来的 条sql查询变成了 +n条

）iterator 查询时 一定先去缓存中找（ 条sql查集合 只查出ID） 在没命中时 会再按ID到库中逐一查找 产生 +n条SQL

怎么解决 +N 问题？

）lazy=true hibernate 开始已经默认是lazy=true了 lazy=true时不会立刻查询关联对象 只有当需要关联对象（访问其属性 非id字段）时才会发生查询动作

）使用二级缓存 二级缓存的应用将不怕 +N 问题 因为即使第一次查询很慢（未命中） 以后查询直接缓存命中也是很快的 刚好又利用了 +N

) 当然你也可以设定fetch= join 一次关联表全查出来 但失去了懒加载的特性

执行条件查询时 iterate（）方法具有着名的 n+ 次查询的问题 也就是说在第一次查询时iterate方法会执行满足条件的查询结果数再加一次（n+ ）的查询 但是此问题只存在于第一次查询时 在后面执行相同查询时性能会得到极大的改善 此方法适合于查询数据量较大的业务数据

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

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

关于数据的有效性

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

也就是说删除 更新 增加数据的时候 同时更新缓存 当然这也包括二级缓存！

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

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

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

一级缓存 二级缓存都有相应的清除方法

其中二级缓存提供的清除方法为

按对象class清空缓存

按对象class和对象的主键id清空缓存

清空对象的集合中的缓存数据等

适合使用的情况

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

适合于使用二级缓存的情况

数据不会被第三方修改

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

数据大小在可接收范围之内

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

数据更新频率低

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

非关键数据（不是财务数据等）

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

因为此时 正确性 的重要性远远大于 高性能 的重要性

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

目前情况

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

多个应用系统同时访问一个数据库

此种情况使用hibernate二级缓存会不可避免的造成数据不一致的问题 此时要进行详细的设计 比如在设计上避免对同一数据表的同时的写入操作 使用数据库各种级别的锁定机制等

动态表相关

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

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

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

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

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

此时执行批量删除后 缓存中会存在已被删除的数据

分析

当执行了第 条（sql批量删除）后 后续的查询只可能是以下三种方式

a session find（）方法

根据前面的总结 find方法不会查询二级缓存的数据 而是直接查询数据库

所以不存在数据有效性的问题

b 调用iterate方法执行条件查询时

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

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

c 用get或load方法按id执行查询

客观上此时会查询得到已过期的数据 但是又因为系统中执行sql批量删除一般是针对中间关联数据表 对于中间关联表的查询一般都是采用条件查询 按id来查询某一条关联关系的几率很低 所以此问题也不存在!

如果某个值对象确实需要按id查询一条关联关系 同时又因为数据量大使用 了sql执行批量删除 当满足此两个条件时 为了保证按id 的查询得到正确的结果 可以使用手动清楚二级缓存中此对象的数据的方法!!(此种情况出现的可能性较小)

建 议

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

如果必须使用sql执行数据的更新 必须清空此对象的缓存数据 调用

SessionFactory evict(class)

SessionFactory evict(class id)等方法

在批量删除数据量不大的时候可以直接采用hibernate的批量删除 这样就不存在绕开hibernate执行sql产生的缓存数据一致性的问题

不推荐采用hibernate的批量删除方法来删除大批量的记录数据

原因是hibernate的批量删除会执行 条查询语句外加 满足条件的n条删除语句 而不是一次执行一条条件删除语句！！当待删除的数据很多时会有很大的性能瓶颈！！！如果批量删除数据量较大 比如超过 条 可以采用JDBC直接删除 这样作的好处是只执行一条sql删除语句 性能会有很大的改善 同时 缓存数据同步的问题 可以采用 hibernate清除二级缓存中的相关数据的方法

调 用

SessionFactory evict(class) ;

SessionFactory evict(class id)等方法

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

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

具体的配置方法

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

ibernate提供了二级缓存的接口

net sf hibernate cache Provider

同时提供了一个默认的 实现net sf hibernate cache HashtableCacheProvider

也可以配置 其他的实现 比如ehcache jbosscache等

具体的配置位置位于hibernate cfg xml文件中

<propertyname= hibernate cache use_query_cache >true</property><propertyname= hibernate cache provider_class >net sf hibernate cache HashtableCacheProvider</property>

很多的hibernate使用者在 配置到 这一步 就以为 完事了

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

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

<hibernate mapping><classname= sobey *** m model entitySystem vo DataTypeVO table= dcm_datatype ><cacheusage= read write /><idname= id column= TYPEID type= java lang Long ><generatorclass= sequence /></id><propertyname= name column= NAME type= java lang String /><propertyname= dbType column= DBTYPE type= java lang String /></class></hibernate mapping>

关键就是这个<cache usage= read write /> 其有几个选择read only read write transactional 等

然后在执行查询时 注意了 如果是条件查询 或者返回所有结果的查询 此时session find()方法 不会获取缓存中的数据 只有调用erate()方法时才会调缓存的数据

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

对于不同的缓存框架具体的配置方法会有不同 但是大体是以上的配置（另外 对于支持事务型 以及支持集群的环境的配置我会争取在后续的文章中中 发表出来）

lishixin/Article/program/Java/ky/201311/28715

⑥ hibernate中session的缓存怎么清除

1. 清空缓存
当调用session.evict(customer); 或者session.clear(); 或者session.close()方法时，Session的缓存被清空。

2. 清理缓存
Session具有一个缓存，位于缓存中的对象处于持久化状态，它和数据库中的相关记录对应，Session能够在某些时间点，按照缓存中持久化对象的属性变化来同步更新数据库，这一过程被称为清理缓存。

在默认情况下，Session会在下面的时间点清理缓存。

当应用程序调用org.hibernate.Transaction的commit()方法的时候，commit()方法先清理缓存，然后在向数据库提交事务；
当应用程序调用Session的list()或者iterate()时（【注】get()和load()方法不行），如果缓存中持久化对象的属性发生了变化，就会先清理缓存，以保证查询结果能能反映持久化对象的最新状态；
当应用程序显式调用Session的flush()方法的时候。