Hibernate 之Hibernate缓存

1、缓存：缓存是什么，解决什么问题？

位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为 Cache（摘自Robbin的《缓存技术浅谈》）。目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快。（请参考http://baike.baidu.com/view/907.htm 了解更多缓存知识）

高速缓存不属于Hibernate等，属于独立产品或框架，可单独使用。

常见缓存算法：

a)         LFU（Least Frequently Used）：最近不常被使用（命中率低），一定时间段内使用次数最少的

b)        LRU（Least Recently Used）：最近很少使用（LinkedHashMap），没有被使用时间最长的

c)        FIFO（First In First Out）：先进先出

2、缓存策略

1．对象缓存

2．查询缓存

3．页面缓存

1．动态页面缓存

2．Servlet缓存

3．页面片段缓存

3、缓存分类

1.         Web缓存：

i.              浏览器缓存：ajax（在客户端缓存）、HTTP协议

ii.          代理服务器缓存

2.       操作系统缓存：如用于减少磁盘操作

3.        数据库缓存：

i.              结果缓存：

ii.             排序缓存

iii.            插入缓存

iv.            日志缓存

v.              ………………

4.         应用程序缓存

i.              对象缓存

ii.              查询缓存

iii.              页面缓存

1.         动态页面静态化：网页静态化、独立图片服务器

2.         页面局部缓存：

3.        请求回应缓存：

4、常见Java缓存框架

?           EHCache

?           OSCache

?           JBossCache

?           SwarmCache

5、通用缓存产品

?           Memcached：在大规模互联网应用下使用，可用于分布式环境，每秒支撑1.5万～2万次请求

?           Tokyo Tyrant：兼容memcached协议，可以持久化存储，支持故障切换，对缓存服务器有高可靠性要求可以使用，每秒支撑0.5万～0.8万次请求

6、基于Web应用的缓存应用场景：

（摘自bluedavy的《大型网站架构演化》）

8、缓存实战：

8.4、ORM缓存

8.4.1、目的：

Hibernate缓存：使当前数据库状态的表示接近应用程序，要么在内存中，要么在应用程序服务器机器的磁盘上。高速缓存是数据的一个本地副本，处于应用程序和数据库之间，可用来避免数据库的命中。

8.4.2、避免数据库命中：

应用程序根据标识符到缓存查，有就返回，没有再去数据库.

8.4.3、ORM缓存分类

一级缓存、二级缓存

8.4.4、缓存范围

1、事务范围高速缓存，对应于一级缓存（单Session）

2、过程（JVM）范围高速缓存，对应于二级缓存（单SessionFactory）

3、集群范围高速缓存，对应于二级缓存（多SessionFactory）

8.4.5、缓存哪些数据

1、很少改变的数据；

2、不重要的数据，如论坛帖子，无需实时的数据；

3、应用程序固有的而非共享的。

4、读大于写有用

8.4.6、Hibernate缓存架构

图摘自《Hibernate in Action》

?           Hibernate中的二级缓存是可插拔的。

?           Hibernate二级缓存支持对象缓存、集合缓存、查询结果集缓存，对于查询结果集缓存可选。

?           查询缓存：需要两个额外的物理高速缓存区域：一个用于存放查询的结果集；另一个用于存储表上次更新的时间戳

8.4.6.2、高速缓存实战(ehcache)

8.4.6.2.1、全局配置(hibernate.cfg.xml)

Java代码  

1. <!-- 开启二级缓存 -->
2. <property name="hibernate.cache.use_second_level_cache">true</property>
3. <!-- 开启查询缓存 -->
4. <property name="hibernate.cache.use_query_cache">true</property>
5. <!-- 二级缓存区域名的前缀 -->
6. <!--<property name="hibernate.cache.region_prefix">h3test</property>-->
7. <!-- 高速缓存提供程序 -->
8. <property name="hibernate.cache.region.factory_class">
9. net.sf.ehcache.hibernate.EhCacheRegionFactory
10. </property>
11. <!-- 指定缓存配置文件位置 -->
12. <property name="hibernate.cache.provider_configuration_file_resource_path">
13. ehcache.xml
14. </property>
15. <!-- 强制Hibernate以更人性化的格式将数据存入二级缓存 -->
16. <property name="hibernate.cache.use_structured_entries">true</property>
17. <!-- Hibernate将收集有助于性能调节的统计数据 -->
18. <property name="hibernate.generate_statistics">true</property>

8.4.6.2.2、ehcache配置（ehcache.xml）

Java代码  

1. <?xml version="1.0" encoding="UTF-8"?>
2. <ehcache name="h3test">
3. <defaultCache
4. maxElementsInMemory="100"
5. eternal="false"
6. timeToIdleSeconds="1200"
7. timeToLiveSeconds="1200"
8. overflowToDisk="false">
9. </defaultCache>
10. </ehcache>

8.4.6.2.3、实体只读缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并只读

Java代码  

1. <hibernate-mapping>
2. <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
3. <cache usage="read-only"/>
4. ……
5. </hibernate-mapping>

2、测试代码

Java代码  

1. public static void readonlyTest() {
2. SessionFactory sf =
3. new Configuration().configure().buildSessionFactory();
4. Session session1 = sf.openSession();
5. Transaction t1 = session1.beginTransaction();
6. //确保数据库中有标识符为1的FarmModel
7. FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
8. //如果修改将报错，只读缓存不允许修改
9. //farm.setName("aaa");
10. t1.commit();
11. session1.close();
12. Session session2 = sf.openSession();
13. Transaction t2 = session2.beginTransaction();
14. farm = (FarmModel) session2.get(FarmModel.class, 1);
15. t2.commit();
16. session2.close();
17. sf.close();
18. }

?           只读缓存不允许更新，将报错Can't write to a readonly object。

?           允许新增，（现在2。0 新增直接添加到二级缓存）

8.4.6.2.4、实体非严格读/写缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并非严格读/写

Java代码  

1. <hibernate-mapping>
2. <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
3. <cache usage="nonstrict-read-write"/>
4. ……
5. </hibernate-mapping>

2、测试代码

Java代码  

1. public static void nonstrictReadWriteTest () {
2. SessionFactory sf =
3. new Configuration().configure().buildSessionFactory();
4. Session session1 = sf.openSession();
5. Transaction t1 = session1.beginTransaction();
6. //确保数据库中有标识符为1的FarmModel
7. FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
8. t1.commit();
9. session1.close();
10. Session session2 = sf.openSession();
11. Transaction t2 = session2.beginTransaction();
12. farm = (FarmModel) session2.get(FarmModel.class, 1);
13. t2.commit();
14. session2.close();
15. sf.close();
16. }

?           允许更新，更新后缓存失效，需再查询一次。

       ?           允许新增，新增记录自动加到二级缓存中。

       ?           整个过程不加锁，不保证。

8.4.6.2.5、实体读/写缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

Java代码  

1. <hibernate-mapping>
2. <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
3. <cache usage="read-write"/>
4. ……
5. </hibernate-mapping>

2、测试代码

Java代码  

1. public static void readWriteTest() {
2. SessionFactory sf =
3. new Configuration().configure().buildSessionFactory();
4. Session session1 = sf.openSession();
5. Transaction t1 = session1.beginTransaction();
6. //确保数据库中有标识符为1的FarmModel
7. FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
8. farm.setName("as");
9. t1.commit();
10. session1.close();
11. Session session2 = sf.openSession();
12. Transaction t2 = session2.beginTransaction();
13. farm = (FarmModel) session2.get(FarmModel.class, 1);
14. t2.commit();
15. session2.close();
16. sf.close();
17. }

?          允许更新，更新后自动同步到缓存。

?          允许新增，新增记录后自动同步到缓存。

?           保证read committed隔离级别及可重复读隔离级别（通过时间戳实现）

?           整个过程加锁，如果当前事务的时间戳早于二级缓存中的条目的时间戳，说明该条目已经被别的事务修改了，此时重新查询一次数据库，否则才使用缓存数据，因此保证可重复读隔离级别。

8.4.6.2.6、实体事务缓存

需要特定缓存的支持和JTA事务支持，此处不演示。

8.4.6.2.7、集合缓存

此处演示读/写缓存示例，其他自测

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

Java代码  

1. <hibernate-mapping>
2. <class name="cn.javass.h3test.model.UserModel" table="TBL_USER">
3. <cache usage="read-write" />
4. <set name="farms" cascade="all" inverse="true" lazy="false">
5. <cache usage="read-write"/>
6. <key column="fk_user_id"/>
7. <one-to-many class="cn.javass.h3test.model.FarmModel"/>
8. </set>
9. </class>
10. </hibernate-mapping>

2、测试代码

Java代码  

1. public static void collectionReadWriteTest() {
2. SessionFactory sf =
3. new Configuration().configure().buildSessionFactory();
4. Session session1 = sf.openSession();
5. Transaction t1 = session1.beginTransaction();
6. //确保数据库中有标识符为118的UserModel
7. UserModel user = (UserModel) session1.get(UserModel.class, 118);
8. user.getFarms();
9. t1.commit();
10. session1.close();
11. Session session2 = sf.openSession();
12. Transaction t2 = session2.beginTransaction();
13. user = (UserModel) session2.get(UserModel.class, 118);
14. user.getFarms();
15. t2.commit();
16. session2.close();
17. sf.close();
18. }

?           和实体并发策略有相同含义；

?           但集合缓存只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

8.4.6.2.8、查询缓存

1、保证全局配置中有开启了查询缓存。

2、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

Java代码  

1. <hibernate-mapping>
2. <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
3. <cache usage="read-write"/>
4. ……
5. </hibernate-mapping>

  3、测试代码

Java代码  

1. public static void queryCacheTest() {
2. SessionFactory sf =
3. new Configuration().configure().buildSessionFactory();
4. Session session1 = sf.openSession();
5. Transaction t1 = session1.beginTransaction();
6. Query query = session1.createQuery("from FarmModel");
7. //即使全局打开了查询缓存，此处也是必须的
8. query.setCacheable(true);
9. List<FarmModel> farmList = query.list();
10. t1.commit();
11. session1.close();
12. Session session2 = sf.openSession();
13. Transaction t2 = session2.beginTransaction();
14. query = session2.createQuery("from FarmModel");
15. //即使全局打开了查询缓存，此处也是必须的
16. query.setCacheable(true);
17. farmList = query.list();
18. t2.commit();
19. session2.close();
20. sf.close();
21. }

?           和实体并发策略有相同含义；

      ?           和集合缓存类似，只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符 去二级缓存查找相应的实体最后组合为集合返回。

 

8.4.6.2.9、高速缓存区域

Hibernate在不同的高速缓存区域保存不同的类（实体）/集合，如果不配置区域默认都保存到“默认缓存”（defaultCache）中。

  每一个区域可以设置过期策略、缓存条目大小等等。

  对于类缓存，默认区域名是全限定类名，如cn.javass.h3test.model.UserModel。

  对于集合而言，默认区域名是全限定类名+属性名，如cn.javass.….UserModel.farms。

  可通过hibernate.cache.region_prefix指定特定SessionFactory的区域前缀，如前缀是h3test，则如类缓存的区域名就是h3test. cn.javass.h3test.model.UserModel。如果应用程序使用多个SessionFactory 这可能是必须的。

 

    可通过<cache usage="read-write" region="区域名"/>自定义区域名，不过默认其实就可以了。

8.4.6.2.10、ehcache配置详解：

1、默认cache：如果没有对应的特定区域的缓存，就使用默认缓存。

Java代码  

1. <defaultCache
2. maxElementsInMemory="100"
3. eternal="false"
4. timeToIdleSeconds="1200"
5. timeToLiveSeconds="1200"
6. overflowToDisk="false">
7. </defaultCache>

2、指定区域cache：通过name指定，name对应到Hibernate中的区域名即可。

Java代码  

1. <cache name="cn.javass.h3test.model.UserModel"
2. maxElementsInMemory="100"
3. eternal="false"
4. timeToIdleSeconds="1200"
5. timeToLiveSeconds="1200"
6. overflowToDisk="false">
7. </cache>

3、cache参数详解：

name:指定区域名

maxElementsInMemory ：缓存在内存中的最大数目

maxElementsOnDisk：缓存在磁盘上的最大数目

eternal ：缓存是否持久

overflowToDisk ： 硬盘溢出数目

timeToIdleSeconds ：当缓存条目闲置n秒后销毁

timeToLiveSeconds ：当缓存条目存活n秒后销毁

memoryStoreEvictionPolicy:缓存算法，有LRU（默认）、LFU、FIFO

  4、StandardQueryCache

用于查询缓存使用，如果指定了该缓存，那么查询缓存将放在该缓存中。

Java代码  

1. <cache
2. name="org.hibernate.cache.StandardQueryCache"
3. maxElementsInMemory="5"
4. eternal="false"
5. timeToLiveSeconds="120"
6. overflowToDisk="true"/>

  如果不给查询设置区域名默认缓存到这，可以通过“query.setCacheRegion("区域名");”来设置查询的区域名。

5、UpdateTimestampsCache

    时间戳缓存，内部使用，用于保存最近更新的表的时间戳，这是非常重要的，无需失效，关闭时间戳缓存区域的过期时间。

Java代码  

1. <cache
2. name="org.hibernate.cache.UpdateTimestampsCache"
3. maxElementsInMemory="5000"
4. eternal="true"
5. overflowToDisk="true"/>

    Hibernate使用时间戳区域来决定被高速缓存的查询结果集是否是失效的。当你重新执行了一个启用了高速缓存的查询时，Hibernate就在时间戳缓存中查找对被查询的（几张）表所做的最近插入、更新或删除的时间戳。如果找到的时间戳晚于高速缓存查询结果的时间戳，那么缓存结果将被丢弃，重新执行一次查询。

 

8.4.6.2.11、什么时候需要查询缓存

  大多数时候无法从结果集高速缓存获益。必须知道:每隔多久重复执行同一查询。

  对于那些查询非常多但插入、删除、更新非常少的应用程序来说，查询缓存可提升性能。但写入多查询少的没有用，总失效。

 

8.4.6.2.12、管理一级缓存

无论何时，当你给save()、update()或 saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。

当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

ScrollableResult cats = sess.createQuery("from Cat as cat").scroll(); //a huge result set

while ( cats.next() ) {

    Cat cat = (Cat) cats.get(0);

    doSomethingWithACat(cat);

    sess.evict(cat);

}

Session还提供了一个contains()方法，用来判断某个实例是否处于当前session的缓存中。

如若要把所有的对象从session缓存中彻底清除，则需要调用Session.clear()。

 

CacheMode参数用于控制具体的Session如何与二级缓存进行交互。

CacheMode.NORMAL - 从二级缓存中读、写数据。

CacheMode.GET - 从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。

CacheMode.PUT - 仅向二级缓存写数据，但不从二级缓存中读数据。

CacheMode.REFRESH - 仅向二级缓存写数据，但不从二级缓存中读数据。通过 hibernate.cache.use_minimal_puts的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。

 

8.4.6.2.12、管理二级缓存

对于二级缓存来说，在SessionFactory中定义了许多方法， 清除缓存中实例、整个类、集合实例或者整个集合。

sessionFactory.evict(Cat.class, catId); //evict a particular Cat

sessionFactory.evict(Cat.class);  //evict all Cats

sessionFactory.evictCollection("Cat.kittens", catId); //evict a particular collection of kittens

sessionFactory.evictCollection("Cat.kittens"); //evict all kitten collections

sessionFactory.evictQueries()//evict all queries

8.4.6.2.13、监控二级缓存

如若需要查看二级缓存或查询缓存区域的内容，你可以使用统计（Statistics） API。

通过sessionFactory.getStatistics()；获取Hibernate统计信息。

此时，你必须手工打开统计选项。

hibernate.generate_statistics true

hibernate.cache.use_structured_entries true

具体详见“hibernate监控.rar”（需要自己稍微改改才能用）

需要修改head.jsp中的如下代码获取sessionFactory

Java代码  

1. if(sessionFactory == null) {
2. WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
3. sessionFactory = (SessionFactory)applicationContext.getBean("userSessionFactory");
4. }

参考资料:

Robbin的《缓存技术浅谈》

百度百科的高速缓存知识 http://baike.baidu.com/view/907.htm

bluedavy的《大型网站架构演化》（http://www.blogjava.net/BlueDavy/archive/2008/09/03/226749.html）

《Hibernate in Action》

• hibernate监控.rar (10.7 KB)
• 下载次数: 258

• 查看图片附件