Hibernate缓存说明

2017-04-23 20:42 阅读 511 次 评论 0 条

1、缓存:缓存是什么,解决什么问题?

位于速度相差较大的两种硬件/软件之间的,用于协调两者数据传输速度差异的结构,均可称之为 Cache。目的:让数据更接近于应用程序,协调速度不匹配,使访问速度更快

高速缓存就是性能调优,不属于Hibernate等,属于独立产品或框架,可单独使用。

常见缓存算法:

  1. LFU(Least Frequently Used:最近不常被使用(命中率低),一定时间段内使用次数最少的
  2. LRU(Least Recently Used:最近很少使用(LinkedHashMap),没有被使用时间最长的
  3. FIFO(First In First Out:先进先出

2、缓存策略

1.对象缓存

2.查询缓存

3.页面缓存

1.动态页面缓存

2.Servlet缓存

3.页面片段缓存

3、缓存分类

  1. Web缓存:
    1. 浏览器缓存:ajax(在客户端缓存)、HTTP协议
    2. 代理服务器缓存
  2. 操作系统缓存:如用于减少磁盘操作
  3. 数据库缓存:
    1. 结果缓存:
    2. 排序缓存
  • 插入缓存
  1. 日志缓存
  2. ………………
  1. 应用程序缓存
    1. 对象缓存
    2. 查询缓存
  • 页面缓存
    1. 动态页面静态化:网页静态化、独立图片服务器
    2. 页面局部缓存:
    3. 请求回应缓存:

4、常见Java缓存框架

  • EHCache
  • OSCache
  • JBossCache
  • SwarmCache

5、通用缓存产品

  • Memcached:在大规模互联网应用下使用,可用于分布式环境,每秒支撑5万~2万次请求
  • Tokyo Tyrant:兼容memcached协议,可以持久化存储,支持故障切换,对缓存服务器有高可靠性要求可以使用,每秒支撑5万~0.8万次请求
  • Mongodb:nosql文档数据库,类似于缓存但持久化,适用于海量存储,读多写少。

 

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

7、Web应用系统存在哪些速度差异?

  • 读文件系统 ->  读硬盘
  • 读数据库内存 ->  读文件系统
  • 读应用内存 ->  访问数据库服务器
  • 读静态文件 ->  访问应用服务器
  • 读浏览器缓存 ->  访问网站

 

 

8、缓存实战:

8.1、Web缓存

8.1.1、ajax缓存

8.1.2、HTTP协议

8.2、数据库缓存:

8.2.1、结果缓存

8.2.2、排序缓存

8.2.3、插入缓存

8.2.4、日志缓存

8.2.5、………………

8.3、应用程序缓存

8.3.1、对象缓存

8.3.2、查询缓存

8.3.3、页面缓存

8.3.3.1、动态页面静态化:网页静态化、独立图片服务器

8.3.3.2、页面局部缓存

8.3.3.3、请求回应缓存

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、不重要的数据,如论坛帖子,无需实时的数据(站内信、邮件(如每隔15秒更新一次));

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

4、读大于写有用

8.4.6Hibernate缓存架构

  • Hibernate中的二级缓存是可插拔的。
  • Hibernate二级缓存支持对象缓存、集合缓存、查询结果集缓存,对于查询结果集缓存可选。
  • 查询缓存:需要两个额外的物理高速缓存区域:一个用于存放查询的结果集;另一个用于存储表上次更新的时间戳

8.4.6.1、Hibernate二级缓存

  1、高速缓存策略和高速缓存提供程序

2、高速缓存策略

2.1、二级高速缓存是否启用

        2.2、高速缓存过期策略(LRU、LFU、FIFO)

        2.3、高速缓存的物理格式(内存、文件、集群)

2.4、并发策略

3、内建的并发策略

3.1只读缓存:适用于从不改变的数据,只用于引用数据。如果你的应用程序只需读取一个持久化类的实例,而无需对其修改, 那么就可以对其进行只读缓存。这是最简单,也是实用性最好的方法。甚至在集群中,它也能完美地运作。

Ehcache缓存那些只读的数据。

如果要修改一个只读缓存的数据,抛出Can't write to a readonly object。但允许新增。

 

3.2读/写缓存:利用时间戳机制,维护读取提交隔离,并且只在非集群环境中可用。还是给主要用于读取的数据使用这种策略,因为在这种数据中防止并发事务中的废弃数据最为关键,极少情况用于更新。(内部通过锁保证顺序)

如果应用程序需要更新数据,那么使用读/写缓存 比较合适。 如果应用程序要求“序列化事务”的隔离级别(serializable transaction isolation level),那么就决不能使用这种缓存策略。 如果在JTA环境中使用缓存,你必须指定hibernate.transaction.manager_lookup_class属性的值, 通过它,Hibernate才能知道该应用程序中JTA的TransactionManager的具体策略。 在其它环境中,你必须保证在Session.close()、或Session.disconnect()调用前, 整个事务已经结束。 如果你想在集群环境中使用此策略,你必须保证底层的缓存实现支持锁定(locking)。Hibernate内置的缓存策略并不支持锁定功能。

Ehcache缓存那些有时候更新的数据,维护读取提交隔离语义。如果数据库是可重复读取隔离级别,该并发策略也能维护这个语义。可重复读取隔离级别是并发更新的折中解决方案。内部通过锁实现,可能发生线程堵塞。一个异步的并发策略

 

  3.3、非严格读/写缓存:不提供高速缓存和数据库之间的一致性保证。如果有可能并发访问相同的实体,你应该配置一个足够短的超时时限。否则,则可能从高速缓存中读取废弃的数据。如果数据几乎不变(几小时、几天),并且废弃的数据不可能是关键的关注点,那就使用这种策略。(内部不通过锁保证顺序),

如果应用程序只偶尔需要更新数据(也就是说,两个事务同时更新同一记录的情况很不常见),也不需要十分严格的事务隔离, 那么比较适合使用非严格读/写缓存策略。如果在JTA环境中使用该策略, 你必须为其指定hibernate.transaction.manager_lookup_class属性的值, 在其它环境中,你必须保证在Session.close()、或Session.disconnect()调用前, 整个事务已经结束。

Ehcache缓存那些有时候更新的数据,内部将不通过锁实现,如果并发访问一个条目不保证返回数据库中最新版本的数据,因此请配置超时时间。只依赖于缓存过期(超时)。一个异步的并发策略

 

3.4、事务缓存:只可用于托管环境,如有必要,它还保证完全的事务隔离级别直到可重复读。给主要用于读取的数据使用这种策略,因为在这种数据中防止并发事务中的废弃数据最为关键,极少情况用于更新。

Hibernate的事务缓存策略提供了全事务的缓存支持, 例如对JBoss TreeCache的支持。这样的缓存只能用于JTA环境中,你必须指定 为其hibernate.transaction.manager_lookup_class属性。

一个异步的并发策略,需要底层支持。

4、选择高速缓存提供程序

8.4.6.2、高速缓存实战(ehcache)

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

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>
<!-- 二级缓存区域名的前缀 -->
<!--<property name="hibernate.cache.region_prefix">h3test</property>-->
<!-- 高速缓存提供程序 -->
<property name="hibernate.cache.region.factory_class">
net.sf.ehcache.hibernate.EhCacheRegionFactory
</property>
<!-- 指定缓存配置文件位置 -->
<property name="hibernate.cache.provider_configuration_file_resource_path">
ehcache.xml
</property>
<!-- 强制Hibernate以更人性化的格式将数据存入二级缓存 -->
<property name="hibernate.cache.use_structured_entries">true</property>

<!-- Hibernate将收集有助于性能调节的统计数据 -->
<property name="hibernate.generate_statistics">true</property>

8.4.6.2.2、ehcache配置(ehcache.xml)

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="h3test">
<defaultCache
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200"
overflowToDisk="false">
</defaultCache>
</ehcache>

8.4.6.2.3、实体只读缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置,表示实体缓存并只读
<hibernate-mapping>
<class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
<cache usage="read-only"/>
……
</hibernate-mapping>

2、测试代码

public static void readonlyTest() {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();

Session session1 = sf.openSession();
Transaction t1 = session1.beginTransaction();
//确保数据库中有标识符为1的FarmModel
FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
//如果修改将报错,只读缓存不允许修改
//farm.setName("aaa");
t1.commit();
session1.close();

Session session2 = sf.openSession();
Transaction t2 = session2.beginTransaction();

farm = (FarmModel) session2.get(FarmModel.class, 1);

t2.commit();
session2.close();
sf.close();
}

  • 只读缓存不允许更新,将报错Can't write to a readonly object。
  • 允许新增,新增记录不自动加到二级缓存中,需要再查询一次。

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

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

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

2、测试代码

public static void nonstrictReadWriteTest () {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();

Session session1 = sf.openSession();
Transaction t1 = session1.beginTransaction();
//确保数据库中有标识符为1的FarmModel
FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
t1.commit();
session1.close();

Session session2 = sf.openSession();
Transaction t2 = session2.beginTransaction();

farm = (FarmModel) session2.get(FarmModel.class, 1);

t2.commit();
session2.close();
sf.close();
}

  • 允许更新,更新后缓存失效,需再查询一次。
  • 允许新增,新增记录自动加到二级缓存中。
  • 整个过程不加锁,不保证。

8.4.6.2.5、实体读/写缓存

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

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

2、测试代码

public static void readWriteTest() {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();

Session session1 = sf.openSession();
Transaction t1 = session1.beginTransaction();
//确保数据库中有标识符为1的FarmModel
FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
farm.setName("as");
t1.commit();
session1.close();

Session session2 = sf.openSession();
Transaction t2 = session2.beginTransaction();
farm = (FarmModel) session2.get(FarmModel.class, 1);
t2.commit();
session2.close();
sf.close();
}

  • 允许更新,更新后自动同步到缓存。
  • 允许新增,新增记录后自动同步到缓存。
  • 保证read committed隔离级别及可重复读隔离级别(通过时间戳实现)
  • 整个过程加锁,如果当前事务的时间戳早于二级缓存中的条目的时间戳,说明该条目已经被别的事务修改了,此时重新查询一次数据库,否则才使用缓存数据,因此保证可重复读隔离级别。

8.4.6.2.6、实体事务缓存

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

 

8.4.6.2.7、集合缓存

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

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

<hibernate-mapping>
<class name="cn.javass.h3test.model.UserModel" table="TBL_USER">
<cache usage="read-write" />
<set name="farms" cascade="all" inverse="true" lazy="false">
<cache usage="read-write"/>
<key column="fk_user_id"/>
<one-to-many class="cn.javass.h3test.model.FarmModel"/>
</set>
</class>
</hibernate-mapping>

2、测试代码

public static void collectionReadWriteTest() {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();

Session session1 = sf.openSession();
Transaction t1 = session1.beginTransaction();
//确保数据库中有标识符为118的UserModel
UserModel user = (UserModel) session1.get(UserModel.class, 118);
user.getFarms();
t1.commit();
session1.close();

Session session2 = sf.openSession();
Transaction t2 = session2.beginTransaction();
user = (UserModel) session2.get(UserModel.class, 118);
user.getFarms();
t2.commit();
session2.close();
sf.close();
}

  • 和实体并发策略有相同含义;
  • 但集合缓存只缓存集合元素的标识符,在二级缓存中只存放相应实体的标识符,然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

8.4.6.2.8、查询缓存

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

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

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

3测试代码

public static void queryCacheTest() {
SessionFactory sf =
new Configuration().configure().buildSessionFactory();

Session session1 = sf.openSession();
Transaction t1 = session1.beginTransaction();
Query query = session1.createQuery("from FarmModel");
//即使全局打开了查询缓存,此处也是必须的
query.setCacheable(true);
List<FarmModel> farmList = query.list();
t1.commit();
session1.close();

Session session2 = sf.openSession();
Transaction t2 = session2.beginTransaction();
query = session2.createQuery("from FarmModel");
//即使全局打开了查询缓存,此处也是必须的
query.setCacheable(true);
farmList = query.list();
t2.commit();
session2.close();
sf.close();
}

  • 和实体并发策略有相同含义;
  • 和集合缓存类似,只缓存集合元素的标识符,在二级缓存中只存放相应实体的标识符,然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

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:如果没有对应的特定区域的缓存,就使用默认缓存。

<defaultCache
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200"
overflowToDisk="false">
</defaultCache>

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

<cache name="cn.javass.h3test.model.UserModel"
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200"
overflowToDisk="false">
</cache>

 

 

3、cache参数详解:
name:指定区域名
maxElementsInMemory :缓存在内存中的最大数目
maxElementsOnDisk:缓存在磁盘上的最大数目
eternal :缓存是否持久
overflowToDisk : 硬盘溢出数目
timeToIdleSeconds :当缓存条目闲置n秒后销毁
timeToLiveSeconds :当缓存条目存活n秒后销毁
memoryStoreEvictionPolicy:缓存算法,有LRU(默认)、LFU、FIFO

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

<cache
name="org.hibernate.cache.StandardQueryCache"
maxElementsInMemory="5"
eternal="false"
timeToLiveSeconds="120"
overflowToDisk="true"/>

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

5、UpdateTimestampsCache

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

<cache
name="org.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000"
eternal="true"
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缓存说明 | 猿笔记

发表评论


表情