hibernate 缓存

最新推荐文章于 2025-07-25 17:35:15 发布

转载最新推荐文章于 2025-07-25 17:35:15 发布 · 626 阅读

文章标签：

#hibernate #session #cache #数据库 #sql #测试

j2ee 专栏收录该内容

8 篇文章

订阅专栏

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

一、缓存简介 Cache In Hibernate
HIBERNATE 中的 CACHE 有两级 .

一级是在 Session 范围内的 CACHE . 即每个 Session 有自己的一个 CACHE, 当前操作的对象都会被保留在 CACHE 中 . 但是 Session 关闭后这个 CACHE 也就没有 . 可见这级 CACHE 的生命期是很短的 . （使用 id 进行关键字存储：缓存的 key 就是 ID ， value 是 POJO ） ( 缓存的是实体对象 )

另一级 CACHE 是在 SessionFactory 范围的 , 可以被来自同一个 SessionFactory 的 Session 共享 . 在 HIBERNATE 的文档中称其为 SECOND LEVEL CACHE. 显然后者的优势较明显 , 也比较复合当前的使用环境 . 它可以使用不同的缓存实现，如 EhCache 、 JBossCache 、 OsCache 等（二级缓存是缓存实体对象的）

还有一个类型的 CACHE 就是 QueryCache . 它的作用就是缓存一个 Query 以及 Query 返回对象的 Identifier 以及对象的类型 . 有了 QueryCache 后就可以高效的使用 SECOND LEVEL CACHE.

hibernate 查询缓存 (hibernate 默认是关闭的 )
查询缓存是针对普通属性结果集的缓存
对实体对象的结果集只缓存 id
查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束
查询缓存的配置和使用：
1. 启用查询缓存：在 hibernate .cfg.xml 中加入：
<property name=”hibernate .cache.use_query_cache”>true</property>
2. 在程序中必须手动启用查询缓存，如： query.setCacheable(true);

QueryCache 用来缓存查询语句 , 及查询结果集中对象的 Identifier 与 Type. 当再次使用已缓存的 Query 时 , 就可以通过对象的 Identifier 与 Type 在 SECOND LEVEL CACHE 中查找实际的对象 .

对于查询缓存来说，缓存的 key 是根据 hql 生成的 sql ，再加上参数，分页等信息（可以通过日志输出看到，不过它的输出不是很可读，最好改一下它的代码）。

注：一级缓存也叫 session 级的缓存或事务缓存。 Hibernate 二级缓存也称为进程级的缓存或 SessionFactory 级的缓存。二级缓存是全局缓存，它可以被所有的 session 共享。二级缓存的生命周期和 SessionFactory 的生命周期一致， SessionFactory 可以管理二级缓存。

二、缓存的范围

缓存的范围分为 3 类 :
1. 事务范围
      事务范围的缓存只能被当前事务访问 , 每个事务都有各自的缓存 , 缓存内的数据通常采用相互关联的对象形式 . 缓存的生命周期依赖于事务的生命周期 , 只有当事务结束时 , 缓存的生命周期才会结束 . 事务范围的缓存使用内存作为存储介质 , 一级缓存就属于事务范围 .
2. 应用范围
    应用程序的缓存可以被应用范围内的所有事务共享访问 . 缓存的生命周期依赖于应用的生命周期 , 只有当应用结束时 , 缓存的生命周期才会结束 . 应用范围的缓存可以使用内存或硬盘作为存储介质 , 二级缓存就属于应用范围 .
3. 集群范围
      在集群环境中 , 缓存被一个机器或多个机器的进程共享 , 缓存中的数据被复制到集群环境中的每个进程节点 , 进程间通过远程通信来保证缓存中的数据的一致 , 缓存中的数据通常采用对象的松散数据形式 .

三、缓存的方式

有四种，分别为：

　　 CacheConcurrencyStrategy.NONE

　　 CacheConcurrencyStrategy.READ_ONLY ，只读模式，在此模式下，如果对数据进行更新操作，会有异常；

　　 CacheConcurrencyStrategy.READ_WRITE ，读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了，直接就去数据库查询；

　　 CacheConcurrencyStrategy.NONSTRICT_READ_WRITE ，不严格的读写模式则不会的缓存数据加锁；

　　 CacheConcurrencyStrategy.TRANSACTIONAL ，事务模式指缓存支持事务，当事务回滚时，缓存也能回滚，只支持 JTA 环境。

缓存的注释写法如下，加在 Entity 的 java 类上：

　　 @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

四、缓存的管理

Hibernate 的缓存管理
一级缓存的管理 :
evit(Object obj) 将指定的持久化对象从一级缓存中清除 , 释放对象所占用的内存资源 , 指定对象从持久化状态变为脱管状态 , 从而成为游离对象 .
clear() 将一级缓存中的所有持久化对象清除 , 释放其占用的内存资源
contains(Object obj) 判断指定的对象是否存在于一级缓存中 .
flush() 刷新一级缓存区的内容 , 使之与数据库数据保持同步 .

二级缓存的管理 :
evict(Class arg0, Serializable arg1) 将某个类的指定 ID 的持久化对象从二级缓存中清除 , 释放对象所占用的资源 .

evictCollection(String arg0) 将指定类的所有持久化对象的指定集合从二级缓存中清除 , 释放其占用的内存资源 .

如何避免一次性大量的实体数据入库导致内存溢出
* 先 flush ，再 clear

如果数据量特别大，考虑采用 jdbc 实现，如果 jdbc 也不能满足要求，可以考虑采用数据库本身的特定导入工具

五、什么样的数据不适合放在二级缓存中来 ?
下面这几种情况就不适合加载到二级缓存中 :
1. 经常被修改的数据
2. 绝对不允许出现并发访问的数据
3. 与其他应用共享的数据
下面这己种情况合适加载到二级缓存中 :
1. 数据更新频率低
2. 允许偶尔出现并发问题的非重要数据
3. 不会被并发访问的数据
4. 常量数据
5. 不会被第三方修改的数据

六、二级缓存的配置

Hibernate 的二级缓存功能是靠配置二级缓存插件来实现的 ,Hibernate 为了集成这些插件 ,Hibernate 提供了 org.hibernate.cache.CacheProvider 借口 , 它充当缓存插件与 Hibernate 之间的适配器 .

常用的二级缓存插件
EHCache org.hibernate.cache.EhCacheProvider
OSCache org.hibernate.cache.OSCacheProvider
SwarmCahe org.hibernate.cache.SwarmCacheProvider
JBossCache org.hibernate.cache.TreeCacheProvider

设置 hibernate.cache.provider_class 。

我们这里用 ehcache ，如
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
由于这是 HIBERNATE 默认的 CACHE 提供者 , 所以无须做什么设置 .

只要在 src 中添加 ehcache 的配置文件 ehcache.xml:

<cache name="goncha.hb.bean.Person" maxElementsInMemory="10" eternal="false"

timeToIdleSeconds="100" timeToLiveSeconds="100" overflowToDisk="false" />

<cache name="goncha.hb.bean.Address" maxElementsInMemory="10" eternal="false"

timeToIdleSeconds="100" timeToLiveSeconds="100" overflowToDisk="false" />

</ehcache>

七、哪些方法支持缓存

*get()
*load()
*iterate() ( 查询实体对象 )

save()

查询缓存只对 query.list() 起作用

一级缓存测试：

1 ． Load 测试 : 在同一个 session 中发出两次 load 查询（ 1 ）

2 ． Get 测试 : 在同一个 session 中发出两次 get 查询（ 1 ）

3 ． iterate 测试 : 在同一个 session 中发出两次 iterator 查询（ 1 （ id ） +N ， 1 （ id ））

4 ． Iterate 查询属性测试 : 同一个 session 中发出两次查询属性（ 2 次， iterate 查询普通属性，一级缓存不会缓存，所以会发出 sql ）

5 ．同一个 session 中先 save ，再发出 load 查询 save 过的数据 --save 是使用缓存的

6 ．同一个 session 中先调用 load 查询，然后执行 sessio.clear() 或 session.evict() ，再调用 load 查询（ 2 次）

sessio.clear() 或 session.evict() 可以管理一级缓存，一级缓存无法取消，但可以管理 . 上面的语句都会发出 sql 因为一级缓存中的实体被清除了

7 ．向数据库中批量加入 1000 条数据

// 每一定条数据就强制 session 将数据持久化，同时清除缓存，避免大量数据造成内存溢出

开启二级缓存测试：

1 ．开启两个 session 中发出两次 load 查询（ get 与 load 一样， 1 次） ,

2 ．开启两个 session ，分别调用 load ，再使用 sessionFactory 清楚二级缓存（ 2 次）

3 ．一级缓存和二级缓存的交互

session.setCacheMode(CacheMode.GET); // 设置成只是从二级缓存里读 , 不向二级缓存里写数据（ 2 ）

session.setCacheMode(CacheMode.PUT); // 设置成只是向二级缓存里写数据，不读数据（ 2 次）

开启 hibernate 查询缓存测试：

1 ．开启查询缓存，关闭二级缓存，开启一个 session ，分别调用 query.list （查询属性）（ 1 次）

2 ．开启查询缓存，关闭二级缓存，开启两个 session ，分别调用 query.list （查询属性）

（ 1 次）第二次没有去查询数据库，因为查询缓存生命周期与 session 生命周期无关

3 ．开启查询缓存，关闭二级缓存，开启两个 session ，分别调用 query.iterate （查询属性）

（ 2 次）第二去查询数据库，因为查询缓存只对 query.list() 起作用，对 query.iterate() 不起作用 , 也就是说 query.iterate() 不使用查询缓存

4 ．关闭查询缓存，关闭二级缓存，开启两个 session ，分别调用 query.list （查询实体对象）第二去查询数据库，因为 list 默认每次都会发出查询 sql

5 ．开启查询缓存，关闭二级缓存，开启两个 session ，分别调用 query.list （查询实体对象）第二去查询数据库时，会发出 N 条 sql 语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存会缓存实体对象的 id ，所以 hibernate 会根据实体对象的 id 去查询相应的实体，如果缓存中不存在相应的实体，那么将发出根据实体 id 查询的 sql 语句，否则不会发出 sql ，使用缓存中的数据

6 ．开启查询缓存，开启二级缓存，开启两个 session ，分别调用 query.list （查询实体对象）第二不会发出 sql ，因为开启了二级缓存和查询缓存，查询缓存缓存了实体对象的 id 列表， hibernate 会根据实体对象的 id 列表到二级缓存中取得相应的数据

八、二级缓存在项目中的集成和使用

1. 将 echcache.xml 文件拷贝到 src 下 , 二级缓存 hibernate 默认是关闭的，手动开启
2. 开启二级缓存，修改 hibernate .cfg.xml 文件 ,
<property name=”hibernate .cache.user_second_level_cache”>true</property>
3. 指定缓存产品提供商
<property name=”hibernate .cache.provider_calss”>org.hibernate .cache.EhCacheProvider</property>
4. 指定那些实体类使用二级缓存（两种方法，推荐使用第二种）
第一种：在 *.hbm.xml 中，在 <id> 之前加入
<cache usage=”read-only” />, 使用二级缓存
第二种：在 hibernate .cfg.xml 配置文件中 , 在 <mapping resource=”com/Studnet.hbm.xml” /> 后面加上：
<class-cache class=” com.Studnet” usage=”read-only” />