hibernate中提供了两级缓存，一级缓存是Session级别的缓存，它属于事务范围的缓存，该级缓存由hibernate管理，应用程序无需干预；二级缓存是SessionFactory级别的缓存，该级缓存可以进行配置和更改，并且可以动态加载和卸载，hibernate还为查询结果提供了一个查询缓存，它依赖于二级缓存；

一、什么是缓存

　　缓存是位于应用程序和永久性数据存储源之间用于临时存放复制数据的内存区域，缓存可以降低应用程序之间读写永久性数据存储源的次数，从而提高应用程序的运行性能；

　　hibernate在查询数据时，首先会到缓存中查找，如果找到就直接使用，找不到时才从永久性数据存储源中检索，因此，把频繁使用的数据加载到缓存中，可以减少应用程序对永久性数据存储源的访问，使应用程序的运行性能得以提升。

　　换言之，就是用空间换时间。

二、缓存优劣势

　　优势：提升性能，节约时间。
　　劣势：占内存。不及时性。

三、缓存何时使用

　　1.内存小

　　2.更新快

　　3.访问频率低

　　4.缓存版本多

四、缓存分类

　　一级缓存 - 默认带的。Session内的缓存。Session 提交之前。访问可以自动读缓存。

@Test

    public void testfirstleve1(){

        Session session = null;

        try{

            session = HibernateUtil.getSession();

            Info data1 = session.get(Info.class, "p003");

            HibernateUtil.closeSession();

            session = HibernateUtil.getSession();//删除这一行以及上面一行时，返回的结果为true

            Info data2 = session.get(Info.class, "p003");

            System.out.println(data1==data2);

        }

        catch(Exception e){

            e.printStackTrace();

        }

        finally{

            HibernateUtil.closeSession();

        }

    }

　　使用 load和get加载对象的时候，会自动加载到缓存，读取的也会读缓存。
　　使用hql查询多条数据库，如果使用getResultList()默认是无法放到缓存中的。使用iterator()可以用在缓存中。

@Test

    public void testfirstleve2(){

        Session session = null;

        try{

            session = HibernateUtil.getSession();

//

//            Iterator<Info> iter= session.createQuery("from Info").iterate();

//            while(iter.hasNext()){

//                System.out.println(iter.next().getName());

//            }

//            Iterator<Info> iter1= session.createQuery("from Info").iterate();

//            while(iter1.hasNext()){

//                System.out.println(iter1.next().getName());

//            }

            List<Info> list1 = session.createQuery("from Info").getResultList();

            List<Info> list2 = session.createQuery("from Info").getResultList();

            System.out.println(list1==list2);

        }

        catch(Exception e){

            e.printStackTrace();

        }

        finally{

            HibernateUtil.closeSession();

        }

    }

输出如下：

Hibernate: select info0_.Code as Code1_1_, info0_.Nation as Nation2_1_, info0_.Name as Name3_1_, info0_.Sex as Sex4_1_, info0_.Birthday as Birthday5_1_ from mydb.info info0_

Hibernate: select info0_.Code as Code1_1_, info0_.Nation as Nation2_1_, info0_.Name as Name3_1_, info0_.Sex as Sex4_1_, info0_.Birthday as Birthday5_1_ from mydb.info info0_

false

若是把上面注释的解开：

Hibernate: select info0_.Code as col_0_0_ from mydb.info info0_

Hibernate: select info0_.Code as Code1_1_0_, info0_.Nation as Nation2_1_0_, info0_.Name as Name3_1_0_, info0_.Sex as Sex4_1_0_, info0_.Birthday as Birthday5_1_0_ from mydb.info info0_ where info0_.Code=?

周丹

Hibernate: select info0_.Code as Code1_1_0_, info0_.Nation as Nation2_1_0_, info0_.Name as Name3_1_0_, info0_.Sex as Sex4_1_0_, info0_.Birthday as Birthday5_1_0_ from mydb.info info0_ where info0_.Code=?

唐墨

Hibernate: select info0_.Code as Code1_1_0_, info0_.Nation as Nation2_1_0_, info0_.Name as Name3_1_0_, info0_.Sex as Sex4_1_0_, info0_.Birthday as Birthday5_1_0_ from mydb.info info0_ where info0_.Code=?

胡

Hibernate: select info0_.Code as Code1_1_0_, info0_.Nation as Nation2_1_0_, info0_.Name as Name3_1_0_, info0_.Sex as Sex4_1_0_, info0_.Birthday as Birthday5_1_0_ from mydb.info info0_ where info0_.Code=?

吴倩

Hibernate: select info0_.Code as col_0_0_ from mydb.info info0_

周丹

唐墨

胡

吴倩

可以看到用iterator()的时候，第一遍是查询语句，第二遍是读取的缓存。

　　二级缓存 - 需要扩展外部插件。SessionFactory内的缓存。Session关了后，只要SessionFactory没有close，还可以使用缓存。

配置EhCache二级缓存：

1.复制三个包到lib文件夹下；

2.在hibernate.cfg.xml中配置，启动二级缓存

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

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

3.把ehcache配置文件复制过来

<!--

  ~ Hibernate, Relational Persistence for Idiomatic Java

  ~

  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.

  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.

  -->

<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by

         its value in the running VM.

         The following properties are translated:

         user.home - User's home directory

         user.dir - User's current working directory

         java.io.tmpdir - Default temp file path -->

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

    <!--Default Cache configuration. These will applied to caches programmatically created through

        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory

        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element

                            is never expired.

        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used

                            if the element is not eternal. Idle time is now - last accessed time

        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used

                            if the element is not eternal. TTL is now - creation time

        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache

                            has reached the maxInMemory limit.

        -->

    <defaultCache

        maxElementsInMemory="10000"

        eternal="false"

        timeToIdleSeconds="120"

        timeToLiveSeconds="120"

        overflowToDisk="true"

        />

    <!--Predefined caches.  Add your cache configuration settings here.

        If you do not have a configuration for your cache a WARNING will be issued when the

        CacheManager starts

        The following attributes are required for defaultCache:

        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.

        maxInMemory       - Sets the maximum number of objects that will be created in memory

        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element

                            is never expired.

        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used

                            if the element is not eternal. Idle time is now - last accessed time

        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used

                            if the element is not eternal. TTL is now - creation time

        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache

                            has reached the maxInMemory limit.

        -->

    <!-- Sample cache named sampleCache1

        This cache contains a maximum in memory of 10000 elements, and will expire

        an element if it is idle for more than 5 minutes and lives for more than

        10 minutes.

        If there are more than 10000 elements it will overflow to the

        disk cache, which in this configuration will go to wherever java.io.tmp is

        defined on your system. On a standard Linux system this will be /tmp"

        -->

    <cache name="sampleCache1"

        maxElementsInMemory="10000"

        eternal="false"

        timeToIdleSeconds="300"

        timeToLiveSeconds="600"

        overflowToDisk="true"

        />

    <!-- Sample cache named sampleCache2

        This cache contains 1000 elements. Elements will always be held in memory.

        They are not expired. -->

    <cache name="sampleCache2"

        maxElementsInMemory="1000"

        eternal="true"

        timeToIdleSeconds="0"

        timeToLiveSeconds="0"

        overflowToDisk="false"

        /> -->

    <!-- Place configuration for your caches following -->

</ehcache>

4.在实体对象的映射文件中的<class>下配置缓存。
<cache usage="read-write"/>这句话放在<class>下的第一句

5.如果使用load或get的时候，不需要其它操作，直接使用的二缓存，中间session关闭也没关系

查询缓存--根据HQL不同,缓存不同的结果
在二级缓存的基础上。加两块：
1.hibernate.cfg.xml中加上
<property name="hibernate.cache.use_query_cache">true</property> <!-- 缓存查询语句，相同的查询语句就不再去查第二遍，但对象没有缓存 -->
2.在HQL的createQuery()后加上setCacheable(true)。

@Test

    public void testsecondleve(){

        Session session = null;

        try{

            session = HibernateUtil.getSession();

            List<Info> list1 = session.createQuery("from Info").setCacheable(true).getResultList();

            List<Info> list2 = session.createQuery("from Info").setCacheable(true).getResultList();

            System.out.println(list1==list2);

        }

        catch(Exception e){

            e.printStackTrace();

        }

        finally{

            HibernateUtil.closeSession();

        }

    }
Hibernate: select info0_.Code as Code1_1_, info0_.Nation as Nation2_1_, info0_.Name as Name3_1_, info0_.Sex as Sex4_1_, info0_.Birthday as Birthday5_1_ from mydb.info info0_

false

这里的list1与list2都是查找同样的from info的hql语句，如果1与2的语句稍有不同，那么返回的查询语句就是两条，不是一条了。

对于返回List<T>对象，使用查询缓存。一级，二级缓存是不会缓存集合对象。

最新文章

  1. Oracle数据库学习笔记
  2. MVVM架构~knockoutjs系列之包括区域级联列表的增删改
  3. Android消息机制入门
  4. CF459D Pashmak and Parmida&#39;s problem （树状数组）
  5. 从数据库导出数为生成excel表
  6. 动手学习TCP：服务端状态变迁
  7. 转：深入理解JavaScript闭包概念
  8. WP8.1 双击两次返回键退出程序
  9. java中静态的代码块，静态变量，静态方法
  10. BZOJ_1629_[Usaco2007_Demo]_Cow_Acrobats_(贪心)
  11. 协议Protocol
  12. Windows下ANSI、Unicode、UTF8字符编码转换
  13. gcc -D选项
  14. logstash 解析mysql slow log
  15. IOS 特定于设备的开发:检查设备接近度和电池状态
  16. js计算剩余分钟
  17. Python中parameters与argument区别
  18. mysql随机查询若干条数据的方法
  19. Golang中使用kafka
  20. CloudStack学习-3

热门文章

  1. git的常用操作指令
  2. python爬虫之路——无头浏览器初识及简单例子
  3. Dungeon Master的两种方法
  4. SD Card Formatter for Mac Download
  5. 中英文字符串截取函数msubstr
  6. bootstrap 翻页的状态
  7. OC和C++的混用1
  8. 监测UITextField的变化
  9. R，RJAVA 安装配置 详细版
  10. k8s调度的预选策略及优选函数