hibernate缓存详解

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>对象，使用查询缓存。一级，二级缓存是不会缓存集合对象。