一级缓存

二级缓存

查询缓存

缓存是为了提高性能

变化不是很大，相对静态的对象放入缓存

对象的创建比较耗时

aaarticlea/png;base64,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" alt="" />

028--01  hibernate一级缓存

一级缓存很短和session的生命周期一致，因此也叫session级缓存或事务级缓存

hibernate一级缓存

那些方法支持一级缓存：

* get()

* load()

* iterate（查询实体对象）

如何管理一级缓存：

* session.clear(),session.evict()

如何避免一次性大量的实体数据入库导致内存溢出

* 先flush，再clear

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

028--02  hibernate二级缓存

Hibernate默认的二级缓存是开启的。

二级缓存也称为进程级的缓存，也可称为SessionFactory级的缓存(因为SessionFactory可以管理二级缓存)，它与session级缓存不一样，一级缓存只要session关闭缓存就不存在了。而二级缓存则只要进程在二级缓存就可用。

二级缓存可以被所有的session共享

二级缓存的生命周期和SessionFactory的生命周期一样，SessionFactory可以管理二级缓存

二级缓存同session级缓存一样，只缓存实体对象，普通属性的查询不会缓存

二级缓存一般使用第三方的产品，如EHCache

1.二级缓存的配置和使用：

配置二级缓存的配置文件：模板文件位于hibernate\etc目录下(如ehcache.xml)，将模板存放在ClassPath目录中，一般放在根目录下(src目录下)

<ehcache>

    <!-- 设置当缓存对象益出时，对象保存到磁盘时的保存路径。

         　　　如　d:\xxxx

         The following properties are translated:

         user.home - User's home directory

         user.dir - User's current working directory

         java.io.tmpdir - windows的临时目录 -->

    <diskStore path="java.io.tmpdir"/>

    <!--默认配置/或对某一个类进行管理

        maxInMemory       - 缓存中可以存入的最多个对象数

        eternal           - true:表示永不失效，false：不是永久有效的。

        timeToIdleSeconds - 空闲时间，当第一次访问后在空闲时间内没有访问，则对象失效，单位为秒

        timeToLiveSeconds - 被缓存的对象有效的生命时间，单位为秒

      overflowToDisk  当缓存中对象数超过核定数(益出时)时，对象是否保存到磁盘上。true:保存；false：不保存

                         如果保存，则保存路径在标签<diskStore>中属性path指定

        -->

    <defaultCache

        maxElementsInMemory="10000"

        eternal="false"

        timeToIdleSeconds="120"

        timeToLiveSeconds="120"

        overflowToDisk="true"

        />      

</ehcache>

2.二级缓存的开启：

Hibernate中二级缓存默认就是开启的，也可以显示的开启

二级缓存是hibernate的配置文件设置如下：

<!-- 开启二级缓存，hibernate默认的二级缓存就是开启的 -->

<property name="hibernate.cache.use_second_level_cache">true</property>

3.指定二级缓存产品提供商：

修改hibernate的 配置文件，指定二级缓存提供商，如下：

<!-- 指定二级缓存提供商 -->

<property name="hibernate.cache.provider_class">

org.hibernate.cache.EhCacheProvider

</property>

以下为常见缓存提供商：

Cache

Provider class

Type

Cluster Safe

Query Cache Supported

Hashtable (not intended for production use)

org.hibernate.cache.HashtableCacheProvider

memory

yes

EHCache

org.hibernate.cache.EhCacheProvider

memory, disk

yes

OSCache

org.hibernate.cache.OSCacheProvider

memory, disk

yes

SwarmCache

org.hibernate.cache.SwarmCacheProvider

clustered (ip multicast)

yes (clustered invalidation)

JBoss TreeCache

org.hibernate.cache.TreeCacheProvider

clustered (ip multicast), transactional

yes (replication)

yes (clock sync req.)

4.指定哪些实体类使用二级缓存：

方法一：在实体类映射文件中，使用<cache>来指定那个实体类使用二级缓存，如下：

<cache

    usage="transactional|read-write|nonstrict-read-write|read-only"  (1)

    region="RegionName"                                              (2)

    include="all|non-lazy"                                           (3)

/>

(1)   usage(必须)说明了缓存的策略: transactional、 read-write、 nonstrict-read-write或 read-only。

(2)   region (可选, 默认为类或者集合的名字(class or collection role name)) 指定第二级缓存的区域名(name of the second level cache region)

(3)   include (可选,默认为 all) non-lazy 当属性级延迟抓取打开时, 标记为lazy="true"的实体的属性可能无法被缓存

另外(首选?), 你可以在hibernate.cfg.xml中指定<class-cache>和 <collection-cache> 元素。

这里的usage 属性指明了缓存并发策略（cache concurrency strategy）。

策略：只读缓存（Strategy: read only）

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

<class name="eg.Immutable" mutable="false">
    <cache usage="read-only"/>
    ....
</class>

策略:读/写缓存（Strategy: read/write）

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

<class name="eg.Cat" .... >
    <cache usage="read-write"/>
    ....
    <set name="kittens" ... >
        <cache usage="read-write"/>
        ....
    </set>
</class>

策略:非严格读/写缓存（Strategy: nonstrict read/write）

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

策略:事务缓存（transactional）

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

没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及其各自适用的并发策略。

表 19.2.  各种缓存提供商对缓存并发策略的支持情况（Cache Concurrency Strategy Support）

Cache

read-only

nonstrict-read-write

read-write

transactional

Hashtable (not intended for production use)

yes

yes

yes

EHCache

yes

yes

yes

OSCache

yes

yes

yes

SwarmCache

yes

yes

JBoss TreeCache

yes

yes

注：此方法要求：必须要标签<cache>放在<id>标签之前

<class name="com.wjt276.hibernate.Student" table="t_student">

        <!--  指定实体类使用二级缓存　-->

       <cache usage="read-only"/>//***********

        <id name="id" column="id">

            <generator class="native"/>

        </id>

        <property name="name" column="name"/>

        <!--

            使用多对一标签映射 一对多双向，下列的column值必需与多的一端的key字段值一样。

         -->

        <many-to-one name="classes" column="classesid"/>

    </class>

方法二：在hibernate配置文件(hibernate.cfg.xml)使用<class-cache>标签中指定

要求：<class-cache>标签必须放在<maping>标签之后。

<hibernate-configuration>

    <session-factory>

        …………

<mapping resource="com/wjt276/hibernate/Classes.hbm.xml"/>

        <mapping resource="com/wjt276/hibernate/Student.hbm.xml"/>

        <class-cache class="com.wjt276.hibernate.Student" usage="read-only"/>

    </session-factory>

</hibernate-configuration>

一般推荐使用方法一。

5.应用范围

没有变化，近似于静态的数据。

6.二级缓存的管理：

1、  清除指定实体类的所有数据

SessionFactory.evict(Student.class);

2、  清除指定实体类的指定对象

SessionFactory.evict(Student.class, 1);//第二个参数是指定对象的ID，就可以清除指定ID的对象

使用SessionFactory清除二级缓存

Session session = null;

        try {

            session = HibernateUtils.getSession();

            session.beginTransaction();

            Student student = (Student)session.load(Student.class, 1);

            System.out.println("student.name=" + student.getName());

            session.getTransaction().commit();

        }catch(Exception e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        }finally {

            HibernateUtils.closeSession(session);

        }

        //管理二级缓存

        SessionFactory factory = HibernateUtils.getSessionFactory();

       //factory.evict(Student.class);

        factory.evict(Student.class, 1);

        try {

            session = HibernateUtils.getSession();

            session.beginTransaction();

            //会发出查询sql，因为二级缓存中的数据被清除了

            Student student = (Student)session.load(Student.class, 1);

            System.out.println("student.name=" + student.getName());

            session.getTransaction().commit();

        }catch(Exception e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        }finally {

            HibernateUtils.closeSession(session);

    }

7.二级缓存的交互

Session session = null;

        try {

           session = HibernateUtils.getSession();

            session.beginTransaction();

            //仅向二级缓存读数据，而不向二级缓存写数据

            session.setCacheMode(CacheMode.GET);

            Student student = (Student)session.load(Student.class, 1);

            System.out.println("student.name=" + student.getName());

            session.getTransaction().commit();

        }catch(Exception e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        }finally {

            HibernateUtils.closeSession(session);

        }

        try {

            session = HibernateUtils.getSession();

            session.beginTransaction();

            //发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据

            Student student = (Student)session.load(Student.class, 1);

            System.out.println("student.name=" + student.getName());

            session.getTransaction().commit();

        }catch(Exception e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        }finally {

           HibernateUtils.closeSession(session);

        }

        try {

           session = HibernateUtils.getSession();

            session.beginTransaction();

            //只向二级缓存写数据，而不从二级缓存读数据

            session.setCacheMode(CacheMode.PUT);

            //会发出查询sql，因为session将CacheMode设置成了PUT

            Student student = (Student)session.load(Student.class, 1);

            System.out.println("student.name=" + student.getName());

            session.getTransaction().commit();

        }catch(Exception e) {

            e.printStackTrace();

            session.getTransaction().rollback();

        }finally {

            HibernateUtils.closeSession(session);

        }

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

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

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

Map cacheEntries = sessionFactory.getStatistics()
        .getSecondLevelCacheStatistics(regionName)
        .getEntries();

此时，你必须手工打开统计选项。可选的，你可以让Hibernate更人工可读的方式维护缓存内容。

hibernate.generate_statistics true
hibernate.cache.use_structured_entries true

8.hibernate查询缓存

查询缓存，是用于缓存普通属性查询的，当查询实体时缓存实体ID。
默认情况下关闭，需要打开。查询缓存，对list/iterator这样的操作会起作用。
可以使用<property name=”hibernate.cache.use_query_cache”>true</property>来打开查询缓存，默认为关闭。
所谓查询缓存：即让hibernate缓存list、iterator、createQuery等方法的查询结果集。如果没有打开查询缓存，hibernate将只缓存load方法获得的单个持久化对象。
在打开了查询缓存之后，需要注意，调用query.list()操作之前，必须显式调用query.setCachable(true)来标识某个查询使用缓存。
查询缓存的生命周期：当前关联的表发生修改，那么查询缓存生命周期结束
 
 

查询缓存的配置和使用：

* 在hibernate.cfg.xml文件中启用查询缓存，如：

<property name="hibernate.cache.use_query_cache">true</property>

* 在程序中必须手动启用查询缓存，如：

         query.setCacheable(true);
例如：
session = HibernateUtils.getSession();

            session.beginTransaction();

            Query query = session.createQuery("select s.name from Student s");

//启用查询查询缓存

            query.setCacheable(true);

            List names = query.list();

            for (Iterator iter=names.iterator();iter.hasNext(); ) {

                String name = (String)iter.next();

                System.out.println(name);

            }

            System.out.println("-------------------------------------");

            query = session.createQuery("select s.name from Student s");

            //启用查询查询缓存

            query.setCacheable(true);

            //没有发出查询sql，因为启用了查询缓存

            names = query.list();

            for (Iterator iter=names.iterator();iter.hasNext(); ) {

                String name = (String)iter.next();

                System.out.println(name);

            }

         session.getTransaction().commit();
注：查询缓存的生命周期与session无关。
 
查询缓存只对query.list()起作用，query.iterate不起作用，也就是query.iterate不使用

028hibernate缓存(性能优化策略)的更多相关文章

  1. Hibernate3回顾-6-hibernate缓存(性能优化策略)

    主要来源: http://blog.csdn.net/csh624366188/article/details/7612142  (比较详细) http://www.cnblogs.com/20091 ...

  2. 常见性能优化策略的总结 good

    阅读目录 代码 数据库 缓存 异步 NoSQL JVM调优 多线程与分布式 度量系统(监控.报警.服务依赖管理) 案例一:商家与控制区关系的刷新job 案例二:POI缓存设计与实现 案例三:业务运营后 ...

  3. c++ 性能优化策略

    c++ 性能优化策略 作者:D_Guco 来源:CSDN 原文:https://blog.csdn.net/D_Guco/article/details/75729259 1 关于继承:不可否认良好的 ...

  4. 52 条 SQL 语句性能优化策略，建议收藏

    本文会提到 52 条 SQL 语句性能优化策略. 1.对查询进行优化,应尽量避免全表扫描,首先应考虑在where及order by涉及的列上建立索引. 2.应尽量避免在where子句中对字段进行nul ...

  5. 90 % Java 程序员被误导的一个性能优化策略

    我们经常看到一些 Java 性能优化的书或者理念,说不要在循环内定义变量,这样会占用过多的内存影响性能,而要在循环外面定义.接触 Java 这么久以来,相信很多 Java 程序员都被这种代码性能优化策 ...

  6. 在 Android开发中，性能优化策略十分重要

    在 Android开发中,性能优化策略十分重要本文主要讲解性能优化中的布局优化,希望你们会喜欢.目录 示意图 1. 影响的性能 布局性能的好坏 主要影响 :Android应用中的页面显示速度 2. 如 ...

  7. HBase最佳实践－写性能优化策略

    本篇文章来说道说道如何诊断HBase写数据的异常问题以及优化写性能.和读相比,HBase写数据流程倒是显得很简单:数据先顺序写入HLog,再写入对应的缓存Memstore,当Memstore中数据大小 ...

  8. Web前端性能优化策略

    前端性能优化需要从前端的资源类型分析,以减少请求资源和请求时间为目的.目前的类型包括图片.javascript.css.动态数据等,不同的资源对于运算.带宽等的依赖也不同,因此优化的方式也不同.参照以 ...

  9. MIC性能优化策略

    MIC性能优化主要包括系统级和内核级:系统级优化包括节点之间,CPU与MIC之间的负载均衡优化:MIC内存空间优化:计算与IO并行优化:IO与IO并行优化:数据传递优化:网络性能优化:硬盘性能优化等. ...

随机推荐

  1. 关于constraint的用法

    1.主键约束:要对一个列加主键约束的话,这列就必须要满足的条件就是非空因为主键约束:就是对一个列进行了约束,约束为(非空.不重复)以下是代码  要对一个列加主键,列名为id,表名为emp格式为:alt ...

  2. effective c++ Item 48 了解模板元编程

    1. TMP是什么? 模板元编程(template metaprogramming TMP)是实现基于模板的C++程序的过程,它能够在编译期执行.你可以想一想:一个模板元程序是用C++实现的并且可以在 ...

  3. 【PAT_Basic日记】1005. 继续(3n+1)猜想

    #include <stdio.h> #include <stdlib.h> /** 逻辑上的清晰和代码上的清晰要合二为一 (1)首先在逻辑上一定要清晰每一步需要干什么, (2 ...

  4. PHP 安装 phpredis 扩展（二）

    本文主要介绍为 PHP 安装 phpredis 扩展,并用 PHP 代码连接 Redis 服务器. 一.安装 phpredis 扩展 1. Linux.macOS 下安装 #. 下载.解压.安装.编译 ...

  5. static class - 静态类

    通常一个普通类不允许声明为静态的,只有一个内部类才可以.这时这个声明为静态的内部类可以直接作为一个普通类来使用,而不需实例一个外部类. 如下代码所示: 1 public class StaticCls ...

  6. Oracle12c多租户管理用户、角色、权限

    Oracle 数据库 12 c 多租户选项允许单个容器数据库 (CDB) 来承载多个单独的可插拔数据库 (PDB).那么我们如何在容器数据库 (CDB) 和可插拔数据库 (PDB)管理用户权限.背景: ...

  7. Jfinal数据库操作语句中占位符的使用

    占位符的优点: 1.增加SQL代码可读性 2.占位符可以预先编译,提高执行效率 3.防止SQL注入 4.用占位符的目的是绑定变量,这样可以减少数据SQL的硬解析,所以执行效率会提高不少 假设要将id从 ...

  8. LeetCode 题解（一）：Two Sum

    LeetCode : two sum 第一次写博客,算是熟悉这些编辑环境吧,本来是打算在csdn上用markdown写的,结果改了博客介绍就被关闭了,晕死...好了,话不多说,今天打算拿LeetCod ...

  9. Mongodb以及rockmongo安装

    Mongodb安装 以centos6.x_x_64位系统为例,我们使用yum安装 1.添加yum源 在/etc/yum.repos.d/目录下创建文件10genmon.repo(名字随意,.repo结 ...

  10. Python函数之lambda,内置函数,yield生成器等

    lambda 1,用于处理简单逻辑 2,自动返回数据(return) 单参数 >>> func2 = lambda a: a+1>>> result = func2 ...