精华内容
下载资源
问答
  • 级缓存与二级缓存 a.级缓存(session级的缓存):在个session中load同个对象2次,load时,hibernate首先在session缓存中查找对象,如果没找到就到数据库中去load。因此,在同个session中load个对象2次...

    一级缓存与二级缓存

    a.一级缓存(session级的缓存):在一个sessionload同一个对象2次,load时,hibernate首先在session缓存中查找对象,如果没找到就到数据库中去load。因此,在同一个sessionload一个对象2次,只会发出一条sql语句。

    b.二级缓存即sessionfactory级别的缓存,hibernate支持多种二级缓存,常用ehcache

    -------------------------------------------------------------------------------------------------------------------------

    二级缓存的应用步骤:

    1.在hibernate.cfg.xml中加上:

     <property name="cache.use_second_level_cache">true</property>
    <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
    <property name="cache.use_query_cache">true</property>

    在applicationContext.xml中的Hibernate SessionFactory配置:

    <property name="hibernateProperties">
    <props>
    <prop key="hibernate.dialect">
    org.hibernate.dialect.OracleDialect
    </prop>
    <prop key="hibernate.show_sql">false</prop>
    <prop key="hibernate.cache.use_second_level_cache">true</prop>

         <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>

     <prop key="hibernate.cache.use_query_cache">true</prop>
     
    <!--  
    <prop key="hibernate.hbm2ddl.auto">update</prop>
    -->
    </props>
    </property>

    2.把hibernate包里的ehcache.xml文件放到src目录下

    <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="1200"
            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>


     

     i.必须要有的属性:

        name: cache的名字,用来识别不同的cache,必须惟一。

       maxElementsInMemory: 内存管理的缓存元素数量最大限值。

       maxElementsOnDisk: 硬盘管理的缓存元素数量最大限值。默认值为0,就是没有限制。

       eternal: 设定元素是否持久话。若设为true,则缓存元素不会过期。

       overflowToDisk: 设定是否在内存填满的时候把数据转到磁盘上。

    ii.下面是一些可选属性:

        timeToIdleSeconds:设定元素在过期前空闲状态的时间,只对非持久性缓存对象有效。默认值为0,值为0意味着元素可以闲置至无限长时间。

       timeToLiveSeconds: 设定元素从创建到过期的时间。其他与timeToIdleSeconds类似。

        diskPersistent: 设定在虚拟机重启时是否进行磁盘存储,默认为false.(我的直觉,对于安全小型应用,宜设为true)。

       diskExpiryThreadIntervalSeconds: 访问磁盘线程活动时间。

       diskSpoolBufferSizeMB: 存入磁盘时的缓冲区大小,默认30MB,每个缓存都有自己的缓冲区。

       memoryStoreEvictionPolicy: 元素逐出缓存规则。共有三种,Recently Used (LRU)最近最少使用,为默认。 First In First Out (FIFO),先进先出。Less Frequently Used(specified as LFU)最少使用。
    上面的ehcache.xml文件除了defaultCache缓存外,还有sampleCache1和sampleCache2,在给实体设置缓存的时候可以指定缓存
    3.@ecache注解,如下例子:

    @Entity
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    public class Permission{
    	private int id;
    	private String name;
    	@Id
    	@GeneratedValue
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }
     
     
    
    
    
    

    4.加入ehcache-1.5.0.jar包,在hibernate-distribution-3.6.0.Final\lib\optional\ehcache目录下     注意:ehcache使用了commons-logging的包,也要加上二级缓存总结: 

    a.load和iterator默认使用二级缓存

    b.list默认往二级缓存加数据,但是查询的时候不使用

    ----------------------------------------------------------------------------------------------------
    查询缓存:

    如果要query用二级缓存,需打开查询缓存:

    <property name="hibernate.cache.use_query_cache">true</property>
    注意:a.查询缓存依赖于二级缓存,必须打开二级缓存
                b.查询缓存在查询条件一样的时候才会起作用,如果条件不一样则不起作用

                c.调用Query的setCachable(true)方法指明使用二级缓存

    源码eg:

    Session session = sf.openSession();
    		session.beginTransaction();
    		List<Category> categories = (List<Category>)session.createQuery("from Category")
    									.setCacheable(true).list();
    		
    		
    		
    		session.getTransaction().commit();
    		session.close();
    		
    		Session session2 = sf.openSession();
    		session2.beginTransaction();
    		List<Category> categories2 = (List<Category>)session2.createQuery("from Category")
    		.setCacheable(true).list();
    		
    		session2.getTransaction().commit();
    		session2.close();
    



    缓存算法:

     1.LRU:least Recently Used 最近最少用到的

      2.LFU:least Frequently Used(命中率高低)

      3.FIFO:First  In First Out  类似数组,先进先出

    ehcache对这三种算法都支持,我们可以在ehcache.xml中增加:

     <defaultCache
            maxElementsInMemory="10000"  <!--缓存存储的最大数量 -->
            eternal="false"  <!--设定元素是否持久话。若设为true,则缓存元素不会过期 -->
            timeToIdleSeconds="120" <!--设定元素在过期前空闲状态的时间,只对非持久性缓存对象有效。默认值为0,值为0意味着元素可以闲置至无限长时间 -->
            timeToLiveSeconds="1200" <!--设定元素从创建到过期的时间,其他与timeToIdleSeconds类似 -->
            overflowToDisk="true" <!--设定是否在内存填满的时候把数据转到磁盘上 -->
            memoryStoreEvictionPolicy=“LRU”

            />
    好文章:http://blog.csdn.net/nuoyan666/article/details/6577732

    http://www.ibm.com/developerworks/cn/java/j-lo-ehcache/index.html(集群,有时间在看)

    http://hi.baidu.com/yinaddress/blog/item/f333f0d9af38f93e33fa1c28.html

    http://hi.baidu.com/liang125353769/blog/item/a5ec79eb571b44cbd439c92d.html


    展开全文
  • Hibernate二级缓存——SessionFactory

    千次阅读 2016-12-08 10:52:43
    Hibernate二级缓存简介 在《Hibernate级缓存——Session》中介绍了Session级别的级缓存,例如,当如下的代码执行时,由于级缓存的作用,只会发送条select语句:@Test public void testCache(){ Employee ...

    Hibernate二级缓存简介

      在《Hibernate一级缓存——Session》中介绍了Session级别的一级缓存,例如,当如下的代码执行时,由于一级缓存的作用,只会发送一条select语句:

    @Test
        public void testCache(){
    
            Employee employee1 = (Employee) session.get(Employee.class, 1);
            System.out.println(employee1);
    
            Employee employee2 = (Employee) session.get(Employee.class, 1);
            System.out.println(employee2);
        }

    image_1b3e0uaih1m5o1oqu1q3g18r1ksc13.png-19kB

      现在,我们在两次加载代码之间,先关闭当前的session和事务,再重新开启一个session和事务,那么不难理解,由于开启了新的session,所以会打印两条select语句:

    @Test
        public void testCache(){
    
            Employee employee1 = (Employee) session.get(Employee.class, 1);
            System.out.println(employee1);
    
            //提交事务,关session
            transaction.commit();
            session.close();
    
            //开启一个新的session和事务
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();
    
            Employee employee2 = (Employee) session.get(Employee.class, 1);
            System.out.println(employee2);
        }

    image_1b3e116cat3g1gk1fv4brlje1g.png-34.8kB
      那么,有没有办法使就算session关闭,也能缓存employee对象的办法呢?这就是我们现在要介绍的,SessionFactory级别的,Hibernate二级缓存。
      
      缓存(Cache )是计算机领域非常通用的概念。它介于应用程序和永久性数据存储源(如硬盘上的文件或者数据库)之间,其作用是降低应用程序直接读写永久性数据存储源的频率,从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝,应用程序在运行时直接读写缓存中的数据,只在某些特定时刻按照缓存中的数据来同步更新数据存储源。缓存的物理介质通常是内存。
      
      Hibernate中提供了两个级别的缓存:
      1.第一级别的缓存是Session级别的缓存,它是属于事务范围的缓存,即缓存只能被当前事务访问,每个事务都有独自的缓存。缓存的生命周期依赖于事务的生命周期,当事务结束时,缓存也就结束生命周期。在此范围下,缓存的介质是内存。这一级别的缓存是由hibernate管理的,一般情况下无须进行干预。
      2.第二级别的缓存是SessionFactory级别的缓存,它是属于进程范围的缓存。缓存被进程内的所有事务共享。这些事务有可能是并发访问缓存,因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进程的生命周期,进程结束时,缓存也就结束了生命周期。进程范围的缓存可能会存放大量的数据,所以存放的介质可以是内存或硬盘。这一级别的缓存可以进行配置和更改,并且可以动态加载和卸载。
      
      SessionFactory 的缓存可以分为两类:
      内置缓存: Hibernate自带的,不可卸载。通常在Hibernate的初始化阶段,Hibernate会把映射元数据和预定义的SQL语句放到SessionFactory的缓存中,映射元数据是映射文件中数据的复制,而预定义SQL语句是Hibernate根据映射元数据推到出来的。该内置缓存是只读的。
      外置缓存(二级缓存):一个可配置的缓存插件。在默认情况下,SessionFactory不会启用这个缓存插件。外置缓存中的数据是数据库中数据的复制,外置缓存的物理介质可以是内存,也可以是硬盘。
      
      缓存的物理介质通常是内存,而永久性数据存储源的物理介质通常是硬盘或磁盘,应用程序读写内在的速度显然比读写硬盘的速度快,如果缓存中存放的数据量非常大,也会用硬盘作为缓存的物理介质。缓存的实现不仅需要作为物理介质的硬件,同时还需要用于管理缓存的并发访问和过期等策略的软件。因此,缓存是通过软件和硬件共同实现的。
      
      适合放入二级缓存中的数据:
      1.很少被修改;
      2.不是很重要的数据,允许出现偶尔的并发问题。
      
      不适合放入二级缓存中的数据:
      1.经常被修改;
      2.财务数据,绝对不允许出现并发问题;
      3.与其他应用程序共享的数据。
      
      二级缓存的并发访问策略:
      两个并发的事务同时访问持久层的缓存的相同数据时,也有可能出现各类并发问题。
      二级缓存可以设定以下4种类型的并发访问策略,每一种访问策略对应一种事务隔离级别。
      非严格读写(Nonstrict-read-write):不保证缓存与数据库种数据的一致性。提供read uncommitted事务隔离级别。对于极少被修改,而且允许脏读的数据,可以采用这种策略。
      读写型(Read-write):提供read committed事务隔离级别。对于经常读但是很少被修改的数据,可以采用这种隔离类型,它可以防止脏读。(通常选用的策略)
      事务型(Transactional):仅在受管理环境下适用。它提供了repeatable read的事务隔离级别。对于经常读,但是很少被修改的数据,可以采用这种隔离类型,它可以防止脏读和不可重复读。
      只读型(Read-Only):提供serializable事务隔离级别,对于从来不会修改的数据,可以采用这种访问策略,可以避免脏读,不可重复读和幻读。
      
      管理Hibernate的二级缓存:
      Hibernate的二级缓存是进程或者集群范围内的缓存。
      二级缓存是可配置的插件,Hibernate允许选用以下类型的缓存插件:
      EhCache:可作为进程范围的缓存,存放数据的物理介质可以是内存或硬盘,对Hibernate的查询缓存提供了支持。
      OSCache:可作为进程范围的缓存,存放数据的物理介质可以是内存或硬盘,提供了丰富的缓存数据过期策略,对Hibernate的查询缓存提供了支持。
      SwarmCache:可作为群集范围内的缓存,但不支持Hibernate的查询缓存。   JBossCache:可作为群集范围内的缓存,支持事务型并发访问策略,对Hibernate的查询缓存提供了支持。
      
    image_1b3dvptab23t1vc1v1g26c1cei9.png-49.7kB

    使用Hibernate二级缓存的步骤

      
    一、加入二级缓存的jar包及配置文件
      
    1.加入jar包
      image_1b3dvuhed16r4ci0ghv1aj3f4m.png-5.1kB
      
    2.添加配置文件ehcache.xml到src目录下

    <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>
    

    二、配置hibernate.cfg.xml
     
    1.配置启用hibernate的二级缓存

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

    2.配置hibernate二级缓存使用的产品

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

    3.配置对哪些类(或属性)使用 hibernate 的二级缓存

    第一种情况,类级别的二级缓存:(配置对Employee类使用二级缓存)

    <class-cache usage="read-write" class="com.atguigu.hibernate.entities.Employee"/>

    第二种情况,集合级别的二级缓存:(配置对Department类中的Employee集合属性emps使用二级缓存)

    <collection-cache usage="read-write" collection="com.atguigu.hibernate.entities.Department.emps"/>

    注意,当配置对集合属性使用二级缓存时,还需要对集合所属的类,集合中元素的类型使用二级缓存,例如,对于上述集合属性,则还需配置对Department类和Employee类使用二级缓存:(如果不对Employee类配置二级缓存,则会多出n条SQL语句,得不偿失。因为这种情况下缓存的是一个一个的employee的id,当要使用到employee对象时,需要再根据id一条一条地去数据库查询记录)

    <class-cache usage="read-write" class="com.atguigu.hibernate.entities.Department"/>
    <class-cache usage="read-write" class="com.atguigu.hibernate.entities.Employee"/>

    另外,配置对哪些类(或属性)使用二级缓存,还可以在映射文件中配置,例如:
    类级别(在class节点下):

    <cache usage="read-write"/>

    集合级别:(在department映射文件的set节点下)

    <cache usage="read-write"/>

      现在,测试上面的testCache方法,只会打印一条select语句:
      image_1b3e2cv2vad01ntl1rt71oac7o41t.png-18kB
      对于集合的测试也是一样,只会打印两条select语句,一条用于查询department,一条用于查询employee:

    @Test
        public void testCollectionSecondLevelCache(){
            Department dept = (Department) session.get(Department.class, 1);
            System.out.println(dept.getName());
            System.out.println(dept.getEmps().size()); 
    
            transaction.commit();
            session.close();
    
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();
    
            Department dept2 = (Department) session.get(Department.class, 1);
            System.out.println(dept2.getName());
            System.out.println(dept2.getEmps().size()); 
        }

    image_1b3e2epr8r731smq4t0scfca62a.png-30.6kB

    二级缓存配置文件

      下面使用一个修改过的二级缓存配置文件介绍其中各个属性的作用:

    <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 -->
        <!--  
            指定一个目录:当 EHCache 把数据写到硬盘上时, 将把数据写到这个目录下.
        -->     
        <diskStore path="d:\\tempDirectory"/>
    
    
        <!--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"
            />
    
        <!--  
            设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域
            缓存区域(region):一个具有名称的缓存块,可以给每一个缓存块设置不同的缓存策略。
            如果没有设置任何的缓存区域,则所有被缓存的对象,都将使用默认的缓存策略。即:<defaultCache.../>
            Hibernate 在不同的缓存区域保存不同的类/集合。
                对于类而言,区域的名称是类名。如:com.atguigu.domain.Customer
                对于集合而言,区域的名称是类名加属性名。如com.atguigu.domain.Customer.orders
        -->
        <!--  
            name: 设置缓存的名字,它的取值为类的全限定名或类的集合的名字 
            maxElementsInMemory: 设置基于内存的缓存中可存放的对象最大数目 
    
            eternal: 设置对象是否为永久的, true表示永不过期,
            此时将忽略timeToIdleSeconds 和 timeToLiveSeconds属性; 默认值是false 
            timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。
            当对象过期时,EHCache会把它从缓存中清除。如果此值为0,表示对象可以无限期地处于空闲状态。 
            timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。
            如果此值为0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值 
    
            overflowToDisk:设置基于内存的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中 
        -->
        <cache name="com.atguigu.hibernate.entities.Employee"
            maxElementsInMemory="1"
            eternal="false"
            timeToIdleSeconds="300"
            timeToLiveSeconds="600"
            overflowToDisk="true"
            />
    
        <cache name="com.atguigu.hibernate.entities.Department.emps"
            maxElementsInMemory="1000"
            eternal="true"
            timeToIdleSeconds="0"
            timeToLiveSeconds="0"
            overflowToDisk="false"
            />
    
    </ehcache>

    查询缓存

      对于经常使用的查询语句,如果启用了查询缓存,当第一次执行查询语句时,Hibernate会把查询结果存放在查询缓存中,以后再次执行该查询语句时,只需从缓存中获得查询结果,从而提高查询性能。
      默认情况下,Hibernate设置的缓存对HQL和QBC查询是无效的,但可以通过以下步骤使其有效:
      1.配置二级缓存,因为查询缓存依赖于二级缓存.
      2.在hibernate配置文件中声明开启查询缓存。

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

      3.调用Query或者Criteria的setCachable(true)。
      
    例如,在没有配置查询缓存的情况下,下面的代码会打印两条select语句:

    @Test
        public void testQueryCache(){
            Query query = session.createQuery("FROM Employee");
    
            List<Employee> emps = query.list();
            System.out.println(emps.size());
    
            emps = query.list();
            System.out.println(emps.size());
    
        }

    image_1b3e39bve1vg91r2t12i65c91n782n.png-30.6kB
      
      进行了相关配置之后,并且在方法中设置query.setCacheable(true);则只会打印一条select语句:

    @Test
        public void testQueryCache(){
            Query query = session.createQuery("FROM Employee");
            query.setCacheable(true);
    
            List<Employee> emps = query.list();
            System.out.println(emps.size());
    
            emps = query.list();
            System.out.println(emps.size());
    
        }

    image_1b3e3bndj184be4f1mga1gi81baq34.png-18.5kB

      查询缓存适用于如下场合:
      1.应用程序运行时经常使用查询语句
      2.很少对与查询语句检索到的数据进行插入,删除或更新操作

    时间戳缓存区域

      时间戳缓存区域存放了对于查询结果相关的表进行插入,更新或者删除操作的时间戳。Hibernate通过时间戳缓存区域来判断被缓存的查询结果是否过期,其运行过程如下:
      T1时刻执行查询操作,把结果存放在QueryCache区域,记录该区域的时间戳为T1;
      T2时刻(可能在T1之前,也可能在T1之后)对查询结果相关的表进行更新操作,Hibernate把T2时刻存放在UpdateTimestampCache区域。
      T3时刻(在T1,T2之后)执行查询结果前,先比较QueryCache区域的时间戳和UpdateTimestampCache区域的时间戳。若T2>T1,则丢弃原先存放在QueryCache区域的查询结果,重新到数据库中查询数据并放入QueryCache区域;若T2

    @Test
        public void testUpdateTimeStampCache(){
            Query query = session.createQuery("FROM Employee");
            query.setCacheable(true);
    
            List<Employee> emps = query.list();
            System.out.println(emps.size());
    
            Employee employee = (Employee) session.get(Employee.class, 1);
            employee.setSalary(30000);
    
            emps = query.list();
            System.out.println(emps.size());
        }

      在第二次查询的时候,会重新用select去数据库中查找最新的记录。
      image_1b3e56hbmjqu3n719ono39k8m3h.png-40.9kB

    Query接口的iterate()方法

      Query的list方法返回实体类对应表的所有字段,而Query的iterate方法仅返回数据包的ID字段。当使用了iterate方法,然后遍历访问结果集时,先到Session缓存及二级缓存中查看是否存在特定OID的对象,如果存在,直接返回,否则就通过相应的SQL SELECT语句到数据库中查找特定的记录。
      在大多数情况下,应该考虑使用list方法执行查询操作,iterate方法仅在下述情况下可以稍微提高查询性能:
      1.要查询的数据表中包含大量字段;
      2.启用了二级缓存,且二级缓存中可能已经包含了待查询的对象。

    展开全文
  • 级缓存:session级别的缓存 二级缓存:sessionFactory级别的缓存,可以跨session存在(一般在对项目要求的效率很高的情况下考虑使用) 二级缓存适合经常访问、数据量有限、改动不大的情况下。

    一级缓存:session级别的缓存

    二级缓存:sessionFactory级别的缓存,可以跨session存在(一般在对项目要求的效率很高的情况下考虑使用)

    二级缓存适合经常访问、数据量有限、改动不大的情况下。

    关于使用二级缓存的相关配置:

    1)hibernate文档中的ehcache.xml:

    <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>
    
    2)cfg.xml中的配置:
     <!-- Disable the second-level cache  -->
            <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>  //表示没有使用二级缓存使用二级缓存

       <property name="hibernate.cache.use_second_level_cache">true</property>
    	      <property name="cache.provider_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

    3)@cache在类申明之前注解



    Load默认使用二级缓存、iterator默认使用二级缓存

    list默认使用二级缓存加载数据,但是查询的时候不使用,可以通过setCache()使用

    -------------------------------------------------------------------------------------------------

    三、查询缓存(对同一条sql语句重复使用才起作用):

    配合二级缓存使用:

    	      <property name="hibernate.cache.use_second_level_cache">true</property>
    	      <property name="cache.provider_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
    	      <property name="hibernate.cache.use_query_cache">true</property>


    ---------------------------------------------------------------------------------------

    缓存算法(纯为了面试):对于内存中的缓存空间已经满了之后,再往缓存中加入对象时,如何拿出一些对象?
    LRU、LFU、FIFO:
    1、:Least Recently Used

    2、Least Frequently Used

    3、First In First Out



    展开全文
  • Linux之高级缓存DNS

    千次阅读 2018-02-05 21:50:10
    、DNS的高速缓存 1、安装DNS 命令 yum install bind(bind是最广泛使用的开源缓存dns服务器) 2、启动DNS服务 3、将DNS加入火墙允许列表 4、更改dns主配置文件/etc/named.conf令其可以为所有的主机进行网络解析...

    DNS是Domain Name System的英文缩写,被翻译为域名系统,是英特网的一项核心服务,它作为可以将域名和IP相互映射的一个数据库,使用户在访问互联网时只需要记住简单的域名(如www.baidu.com),而不需要记住复杂的被机器直接读取的IP数字串,即DNS的工作就是当用户在输入域名时,帮助用户自动找到该域名对应的IP从而使用户在使用互联网时更加方便。


    一、DNS的高速缓存

    1、安装DNS 命令 yum install bind(bind是最广泛使用的开源缓存dns服务器)

    2、启动DNS服务

    3、将DNS加入火墙允许列表


    4、更改dns主配置文件/etc/named.conf令其可以为所有的主机进行网络解析服务,完成后重启服务

    listen-on port 53 { any; };

    allow-query { any; };

    forwarders { 172.25.254.250; };


    5、客户端加入DNS解析,nameserver=配置好dns的主机


    6、在客户端解析域名,我这里dig www.163.com,可以看到其反馈出其ip地址为1113.142.80.177,实现了域名的解析

    并且可以看到访问时延为1245ms

    但我们再一次dig www.163.com时,会发现其时延变为0ms,这便是dns的高速缓存。即再次访问同一个网址,已经缓存过的会高速的显示出来。


    二、DNS的正向解析

    1、删除主配置文件/etc/named.conf里的forwarders { 172.25.254.250; };那一行

    2、vim  /etc/named.rfc1912.zones 编辑子配置文件复制模板,改为要维护的域(我这里是westos.com)并命名维护的域的主机的配置文件(westos.com.zone),如下图


    3、切换到 /var/named目录下 

    cp -p named.localhost  westos.com.zone复制模板为刚才命名的文件

    编辑westos.com.zone,改成如下图

    @符表示在子配置文件中所设定的那个域名(westos.com),该文件中所有的域名如dns.westos.com的结尾都需要添加一个“.”,否则会被该@符读取

    第一行的TTL是一种设定,后面的1D表示该记录文件里面的各项记录的预设TTL值为86400秒,即刚好一天

    IN定义出目前的记录类型是属于internet class的

    SOA表示目前区域的授权记录开始,其后面的值为区域授权主机和管理信箱

    serial表示修改的时间及次数,当自己在修改记录文件时需要更改serial的值,否则修改无法被slave识别;

    refresh表示数据多久进行一次更新

    retry表示如果slave的对数据更新失败后,多久后进行重试

    expire记录逾期时间,即超过该时间slave未与master进行联系,系统会放弃retry并标记该数据标识为过期

    minimum最小预设TTL的值,如果在文件开头没有设置TTL的值,将以该处的值为准

    这里172.25.254.105表示从105获得解析;172.25.254.111表示把要维护的域www,westos.com解析为172.25.254.111;NS表示域名的名称服务器;A表示名称至ipv4地址。

    4、客户端dig www.westos.com查看,可以看到将www.westos.com解析为172.25.254.111

     


    CNAME解析轮询

    我们刚刚dig www.163.com可以看到查询结果是先将其CNAME两次再看到其真实ip,怎么做到,如下

    1、还是编辑westos.com.zone,这次我们加入CNAME bbs.westos.com.(注意要加. 否则将表示bbs.westos.com.westos.com)

    并且dns自带轮询,我们可以加入两个ip地址一会去查看


    2、客户端dig www.westos.com 多次观察,速度要慢一点 ,可以看到实现解析轮询




    三、反向解析

    1、编辑/etc/named.rfc1912.zones 载文件里最后几行,还是复制模版并改成网段和配置文件


    2、编辑westos.com.ptr文件,PTR表示ipv4/ipv6地址至名称,为了查看结果时明显,将111 222表示两个不同域名


    3、客户端dig -x +地址查看





    四、双向解析

    1、cd /etc cp

    cd /var/named/ cp -p westos.com.zone westos.com.inter
    编辑westos.com.inter将里面的172改为192

    -p named.rfc1912.zones  name .rfc1912.zones.inter

    编辑name .rfc1912.zones.inter 复制上面的模版将里面改为westos.com且指定的file 改为“westos.com.inter”


    2、cd /var/named/ cp -p westos.com.zone   westos.com.inter
    编辑westos.com.inter将里面的172改为192配置好内网和外网



    3、编辑主配置文件 /etc/named.conf,将系统自带的注释掉,编写如下图所示模式:


    localnet表示本地,我这里匹配用户只有自己(用ip表示172.25.254.105),指定文件include是上面创建好的内网文件
    internet
    表示外网  匹配用户其他所有(用ip表示一会用客户端测试),指定文件include是上面创建好的外网文件

    4、分别在105本身和客户端测试

    1)105解析出来是172表示内网


    2)除105外所有都是外网解析,用客户端解析查看为外网192




    五、解析辅助

    这里需要再打开一台虚拟机,重置网络(ip配置为172.25.254.205) ,dns解析(nameserver=172.25.254.205),完成后重启网络;配置好yum源;将其shell名字改为dns-slave,下面再205这台主机上

    1、安装bind

    2、vim /etc/named.conf //注释掉三行(//表示与其相反),如下图所示


    3、vim /etc/namedrfc1912.zones编辑设置与105同步


    4、105主机也编辑vim /etc/named.rfc1912.zones加一行并把法file“westos.com.inter”设置同步,/etc/named.conf里的本地解析用户ip随便改成一个155,因为要实现一个外网同步,所以改变内网解析ip也可以将其注释掉



    5、现在修改105真实主机westos.com.inter里的内容随便更改一个ip记得修改serial那一行,完成后重其服务named,并进行查看;

    辅助端也重启服务dig查看可以实现同步



    六、DNS远程更新

    复制一份inter到/mnt/下一会会用

    1、105中编辑主配置文件/etc/named.conf将自己写的/*  */注释并将系统自带的解开注释


    2、加权限 chmod g+w /var/named

    并打开其他用户可以读写的权限 setsebool -P named_write_master_zones on

    3、vim /etc/named.rfc1912.zones将allow-update一行none改为172.25.254.205


    4、在205直接测试nsupdate添加hello.westos.com完成后105重启服务并查看westos.com.inter查看hello.westos.com是否加入成功 ,如下图



    5、  载尝试删除update deletehellow.westos.com并查看



    七、DNS远程更新加密

    (因为用上面那种方法别人改成相同的ip就可以更改你,所以比较危险,所以需要加密)

    删除inter和jnl文件,并将/mnt/下的inter用cp -p过来 重启服务named

    1、cp -p /etc/rndc.key  /etc/westos.key生成westos.key文件

    2、dnssec-ketgen -a HMAC-MD5 -b 128 -n HOST westos生成密码和钥匙

    (执行后若是卡住,要在主机里打开一个shell随机输入字符即可, -a表示加密模式 -b 表示加密字节 -n Host 表示类型是HOST 名称是westos)


    3、编辑/etc/westos.key

    4、vim /etc/named.conf编辑主配置文件,加入include "/etc/westos.key";



    5、vim /etc/named.rfc1912.zone编辑子配置文件

    完成4、5步重启named服务

    6、发送密码钥匙给允许远程更新的主机 scp Kwestos.+157+36700.* root@172.25.254.205:/mnt/

    7、收到私钥后进行测试:

    1)加入hello

    主机端查看

    2)删除hello

    主机端查看



    八、DHCP对DNS进行动态更新

    删除westos.com.inter 和jnl 并把/mnt下的inter cp -p 回来不要重启named

    1、主机端安装dhcp cp模版配置文件命令:cp /usr/share/doc/dhcp-4.2.5/dhcpd.conf.example   /etc/dhcp/dhcpd.conf

    2、编辑/etc/dhcp/dhcpd.conf


    1)第7行修改为"westos.com";  第8行修改为主机ip:172.25.254.105  第14行打开注释并改为interim
    2)删除27、28行
    3)删除35行以后的
    4)修改30行以后的并修改为上图内容
    完成后重启dhcpd服务

    3、在客户端205修改主机名字为hello.westos.com
    将其网络模式设置为dhcp并重启网络服务

    dig hello.westos.com观测


    展开全文
  • 为什么80%的码农都做不了架构师?>>> ...
  • JPA - 一级二级缓存使用详解

    千次阅读 2017-12-11 21:08:07
    【1】一级缓存JPA默认情况下开启一级缓存。示例代码如下: @Test public void testSecondLevelCache(){ Customer customer1 = entityManager.find(Customer.class, 1); Customer customer2 = entityManager.find...
  • 数据库:mysql1、整体架构参考Ehcache实现MyBatis二级缓存代码(Maven引用对应jar查阅)使用Spring管理Redis连接池模仿EhcacheCache,实现RedisCache2、pom.xml中加入Maven依赖&lt;!--引入项目依赖的jar包 --&...
  • 清除Linux缓存

    千次阅读 2012-04-06 23:11:32
    这是Linux内存管理的个优秀特性,在这方面,区别于 Windows的内存管理。主要特点是,无论物理内存有多大,Linux都将其充份利用,将一些程序调用过的硬盘数据读入内存,利用内存读写的高速特性来提高Linux系统的...
  • JPA学习笔记(11)——使用二级缓存

    千次阅读 2015-08-20 16:13:34
    一级缓存查询两次id为1的userUser user1 = entityManager.find(User.class, 1); User user2 = entityManager.find(User.class, 1);结果发现只调用了次sql查询,因为使用了一级缓存如果查询次后,关掉...
  • 一级缓存 一级缓存是session级别的缓存,在JPA中一个entityManager对应个session,个session就对应个缓存。 查询两次id为1的user User user1 = entityManager.find(User.class, 1); User user2 = ...
  • SpringMVC + MyBatis + Mysql + Redis(作为二级缓存) 配置

    万次阅读 多人点赞 2016-03-03 10:37:47
    参考Ehcache实现MyBatis二级缓存代码(Maven引用对应jar查阅) 使用Spring管理Redis连接池 模仿EhcacheCache,实现RedisCache 2、pom.xml中加入Maven依赖<!-- spring-redis实现 --> <dependency
  • 手动清除linux缓存数据-cache

    千次阅读 2018-07-10 10:06:42
    缓存机制介绍在Linux系统中,为了提高文件系统性能,内核利用部分物理内存分配出缓冲区,用于缓存系统操作和数据文件,当内核收到读写的请求时,内核先去缓存区找是否有请求的数据,有就直接返回,如果没有则...
  • 宝塔Linux面板中,有着自带的301重定向功能(市面上很多面板都有这个功能),然而这时实现绑定域名(主域)301跳转的,如果你要将主域下的好几个二级域名301重定向,就无法直接进行301了,这个时候,就需要使用”配置...
  • linux文件缓存相关

    千次阅读 2015-12-15 15:13:04
    、Page cache和buffer cache的区别 Page cache和buffer cache到底有什么区别呢?很多时候我们不知道系统在做IO操作的时候到底是走了page cache还是buffer cache?其实,buffer cache和page cache是Linux中两...
  • Linux下查询CPU 缓存的工具

    千次阅读 2014-08-01 12:29:55
    Linux下可以使用如下工具查询CPU缓存: 方式1: $ lscpu L1d cache: 32K  (一级数据缓存) L1i cache: 32K  (一级指令缓存) ...L2 cache: 256K  (二级缓存) L3 cache: 8192K (三级缓存) 方式2:
  • linux中的页缓存和文件IO

    千次阅读 多人点赞 2018-04-28 16:37:47
    虽然仔细看过《linux内核设计与实现》,也参考了很多的博客,并且做了linux进程空间、address_space和文件的关系图(设为图1,参考博客),但是对于页缓存和文件IO之间关系的细节一直不是特别明朗。趁着元旦假期看的...
  • 为了使查询更高效所以本文采用redis作为二级缓存 开发环境:maven3.5+eclipse4.5.2+jdk1.7+tomcat1.7 操作系统:win7 64 spring 4.2.4 mybatis 3.4.2 spring-data-redis 1.6.2  redis如果没有linux服务器或者...
  • title: CPU Cache date: 2019-11-17 20:20:30 keywords: cache “CPU .... CPU 与 Memory 内存之间的三级缓存的实现原理 1.1 cache 存在的原理   引入 Cache 的理论基础是程序局部性原理,包括时间局部性和...
  • CPU在运行时首先从级缓存读取数据,如果读取失败则会从二级缓存读取数据,如果仍然失败则再从内存中存读取数据。而CPU从级缓存或二级缓存或主内存中最终读取到数据所耗费的时钟周期差距是非常之大的。
  • linux块设备加速缓存之bcache

    万次阅读 2014-01-04 11:17:08
    很高兴地告诉大家,bcache已经加入linux3.10内核主线了,而最新出炉的RHEL7也带了bcache,这意味着bcache已经正式进入商用阶段。
  • Linux常用高级命令

    千次阅读 2019-03-30 16:39:00
    Linux常用高级命令 目录 linux命令是对Linux系统进行管理的命令。对于Linux系统来说,无论是中央处理器、内存、磁盘驱动器、键盘、鼠标,还是用户等都是文件,Linux系统管理的命令是它正常运行的核心,与之前的DOS...
  • linux查看CPU高速缓存(cache)信息

    万次阅读 2015-11-24 12:26:08
    一、Linux下查看CPU Cache级数,每级大小  (1) 第一种方法: dmesg | grep cache ...(2) 第种方法: ...[root@gc15 ~]# ls /sys/devices/system/cpu/cpu0/cache/index ...一级cache, Data cache i
  • Linux缓存内存(cache memory)

    万次阅读 2018-01-27 14:55:37
    其实Linux与Win的内存管理不同,会尽量缓存内存以提高读写性能,通常叫做Cache Memory。 为什么Linux系统没运行多少程序,显示的可用内存这么少?其实Linux与Win的内存管理不同,会尽量缓存内存以提高读写性能,...
  • Linux清除系统缓存释放内存命令介绍

    万次阅读 2017-03-17 10:24:21
    Cache又分为一级Cache(L1 Cache)和二级Cache(L2 Cache),L1 Cache集成在CPU内部,L2 Cache早期一般是焊在主板上,现在也都集成在CPU内部,常见的容量有256KB或512KB L2 Cache 。   Buffer:缓冲区,一个用于存储...
  • Linux缓存相关知识整理(史上最全!!)

    千次阅读 2018-05-06 00:52:25
    缓存和块缓存概念 页缓存(page cache) 块缓存(buffer cache) 缓存机制的利弊 写缓存 2. 数据同步(刷缓存) flush内核线程 可调参数 flush/sync/fsync系列API及命令介绍 sync 系统命令 sync() fsync() ...
  • 》,今天给大家整理篇关于Redis经常被问到的问题:缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等概念的入门及简单解决方案。 缓存雪崩 缓存雪崩我们可以简单的理解为:由于原有缓存失效,新缓存未...
  • 、概述:现在android应用中不可避免的要使用...在当前的状况下,对于非wifi用户来说,流量还是很贵的,个很耗流量的应用,其用户数量肯定要受到影响。当然,我想,向百度美拍这样的应用,必然也有其内部的图片
  • Linux中怎么搭建DNS服务器 、认识DNS: 首先我们要了解一下什么是域名,当我们在没有DNS域名解析服务器去访问某台服务器的时候,我们只能基于IP去访问,但由于IP难记且不方便。我们需要种来取代它,就是域名,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,580
精华内容 49,432
关键字:

linux一级二级缓存

linux 订阅