Hibernate 之Hibernate缓存

转载 2014年02月12日 11:35:43

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

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

    高速缓存就是性能调优,不属于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缓存:
    1.                          i.              浏览器缓存:ajax(在客户端缓存)、HTTP协议
    2.                        ii.              代理服务器缓存
  2. 操作系统缓存:如用于减少磁盘操作
  3. 数据库缓存:
    1.                          i.              结果缓存:
    2.                        ii.              排序缓存
    3.                       iii.              插入缓存
    4.                      iv.              日志缓存
    5.                        v.              ………………
  4. 应用程序缓存
    1.                          i.              对象缓存
    2.                        ii.              查询缓存
    3.                       iii.              页面缓存
      1. 动态页面静态化:网页静态化、独立图片服务器
      2. 页面局部缓存:
      3. 请求回应缓存:

4、常见Java缓存框架

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

5、通用缓存产品

 

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.6、Hibernate缓存架构

   

 

  • 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之缓存详解

一,缓存的概念 二,缓存的范围 三,Hibernate中的第一级缓存 1,get查询测试: 1>在同一个session中发出两次get查询 public void Query(){ Sessio...
  • an_2016
  • an_2016
  • 2016年08月03日 21:57
  • 16465

Hibernate学习笔记(六)——缓存

一、Hibernate缓存 1、什么是缓存? Hibernate中用到了缓存的概念,那么什么是缓存呢?这里介绍的缓存并不是指计算机的内存或者CPU的一二级缓存,这里的缓存是指为了降低程序对物理数据...

关于hibernate的缓存使用

  1.     关于hibernate缓存的问题:1.1.1.         基本的缓存原理Hibernate缓存分为二级,第一级存放于session中称为一级缓存,默认带有且不能卸载。 第二级是...

hibernate缓存机制详细分析(一级、二级、查询缓存,非常清晰明白)

在本篇随笔里将会分析一下hibernate的缓存机制,包括一级缓存(session级别)、二级缓存(sessionFactory级别)以及查询缓存,当然还要讨论下我们的N+1的问题。 随笔虽长,但我...

浅谈Hibernate3中的缓存

当你的系统出现性能瓶颈时,改善业务逻辑

性能优化(一)Hibernate 利用缓存(一级、二级、查询)提高系统性能

查询缓存 一级缓存 二级缓存

Hibernate中性能优化之缓存

在Hibernate中,提到性能优化,很自然地我们就想到了缓存。缓存是什么,都有哪些呢?接下来就来分享...

Hibernate 缓存机制

====Hibernate 缓存机制 一、why(为什么要用Hibernate缓存?) Hibernate是一个持久层框架,经常访问物理数据库。 为了降低应用程序对物理数据源访问的频...

Hibernate 性能优化及缓存的使用

hibernate性能优化,及二级缓存的配置使用。

hibernate缓存机制详细分析(一级/二级/查询缓存)

在本篇随笔里将会分析一下hibernate的缓存机制,包括一级缓存(session级别)、二级缓存(sessionFactory级别)以及查询缓存,当然还要讨论下我们的N+1的问题。 随笔虽长,但我...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Hibernate 之Hibernate缓存
举报原因:
原因补充:

(最多只允许输入30个字)