Hibernate之缓存详解

最新推荐文章于 2022-12-09 14:04:39 发布
最新推荐文章于 2022-12-09 14:04:39 发布
阅读量4.5k 收藏
点赞数 1
分类专栏： Framework

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

一，缓存的概念

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

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

二，缓存的范围

缓存范围决定了缓存的生命周期，缓存范围分为3类：

1>事务范围

缓存只能被当前事务访问，缓存的生命周期依赖于事务的生命周期，事务结束时，缓存的生命周期也结束了；

2>进程范围

缓存被进程内的所有事务共享，这些事务会并发访问缓存，需要对缓存采用必要的事务隔离机制，缓存的生命周期取决与进程的生命周期，进程结束，缓存的生命周期也结束了；

3>集群范围

缓存被一个或多个计算机的进程共享，缓存中的数据被复制到集群中的每个进行节点，进程间通过远程通信来保证缓存中数据的一致性；

在查询时，如果在事务范围内的缓存中没有找到，可以到进程范围或集群范围的缓存中查找，如果还没找到，则到数据库中查询；

三，Hibernate中的第一级缓存

Hibernate的一级缓存由Session提供，只存在于Session的生命周期中，当应用程序调用Session接口的save(),update(),saveOrupDate(),get(),load()或者Query和Criteria实例的list(),iterate()等方法时，如果Session缓存中没有相应的对象，hibernate就会把对象加入到一级缓存中，当session关闭时，该Session所管理的一级缓存也会立即被清除；

1，get查询测试：

1>在同一个session中发出两次get查询

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Student s1 = (Student)sess.get(Student.class, 2);  
  5.         System.out.println(s1.getName());  
  6.         Student s2 = (Student)sess.get(Student.class, 2);  
  7.         System.out.println(s2.getName());  
  8.         tx.commit();  
  9.         HibernateSessionFactory.closeSession();  
  10.     }</strong></span>  
上面的两次查询，第一次执行了get方法查询了数据库，产生了一条sql语句，第二次执行get方法时，由于在一级缓存中找到了该对象，因此不会查询数据库，不再发出sql语句；

2>开启两个session中发出两次get查询

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>        public void Query(){  
  2.         Session sess1 = HibernateSessionFactory.getSession();  
  3.         Transaction tx1 = sess1.beginTransaction();  
  4.         Student s1 = (Student)sess1.get(Student.class, 2);  
  5.         System.out.println(s1.getName());  
  6.         tx1.commit();  
  7.         HibernateSessionFactory.closeSession();  
  8.         Session sess2 = HibernateSessionFactory.getSession();  
  9.         Transaction tx2 = sess2.beginTransaction();  
  10.         Student s2 = (Student)sess2.get(Student.class, 2);  
  11.         System.out.println(s2.getName());  
  12.         tx2.commit();  
  13.         HibernateSessionFactory.closeSession();  
  14.     }</strong></span>  
上面的两次查询，两次执行get方法时都查询了数据库，产生了两条sql语句，原因在于，第一次执行get方法查询出结果后，关闭了session，缓存被清除了，第二次执行get方法时，从缓存中找不到结果，只能到数据库查询；

2，iterate查询测试

插入一个iteritor查询方式：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Query query = sess.createQuery("from Student");  
  5.         Iterator iter = query.iterate();  
  6.         while(iter.hasNext()){  
  7.                System.out.println(((Student)iter.next()).getName());  
  8.         }  
  9.         tx.commit();  
  10.         HibernateSessionFactory.closeSession();  
  11.     }</strong></span>  
[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Student s1 = (Student)sess.createQuery("from Student s where s.id = 2").iterate().next();  
  5.         System.out.println(s1.getName());  
  6.         Student s2 = (Student)sess.createQuery("from Student s where s.id = 2").iterate().next();  
  7.         System.out.println(s2.getName());  
  8.         tx.commit();  
  9.         HibernateSessionFactory.closeSession();  
  10.     }</strong></span>  
上面的代码执行后会生成三条sql语句，第一次执行iterate().next()时会发出查询id的sql语句(第一条sql语句)，得到s1对象，使用s1对象获得name属性值时会发出相应的查询实体对象的sql语句(第二条sql语句)，第二次执行iterate().next()时会发出查询id的sql语句(第三条sql语句)，但是不会发出查询实体对象的sql语句，因为hibernate使用缓存，不会发出sql语句

3，iterate查询属性测试：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         String name1 = (String)sess.createQuery("select s.name from Student s where s.id = 2").iterate().next();  
  5.         System.out.println(name1);  
  6.         String name2 = (String)sess.createQuery("select s.name from Student s where s.id = 2").iterate().next();  
  7.         System.out.println(name2);  
  8.         tx.commit();  
  9.         HibernateSessionFactory.closeSession();  
  10.     }</strong></span>  
上面的代码第一次执行iterate().next()时发出查询属性的sql语句，第二次执行iterate().next()时也会发出查询属性的sql语句，这是因为iterate查询普通属性，一级缓存不会缓存，所以会发出sql；

4，在一个session中先save，再执行load查询

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Student s = new Student(8, "newAcc", 8, 8);  
  5.         Serializable id = sess.save(s);  
  6.         tx.commit();  
  7.         Student s1 = (Student)sess.load(Student.class, 8);  
  8.         System.out.println(s1.getName());  
  9.         HibernateSessionFactory.closeSession();  
  10.     }</strong></span>  
上面的代码执行save操作时，它会在缓存里放一份，执行load操作时，不会发出sql语句，因为save使用了缓存；

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

Session接口为应用程序提供了两个管理缓存的方法：

1>evict()方法：用于将某个对象从Session的一级缓存中清除；

2>clear()方法：用于将一级缓存中的所有对象全部清楚；

测试：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Student s = (Student)sess.load(Student.class, 1);  
  5.         System.out.println(s.getName());  
  6.         sess.clear();//清除一级缓存中的所有对象  
  7.         Student s1 = (Student)sess.load(Student.class, 1);  
  8.         System.out.println(s1.getName());  
  9.         tx.commit();  
  10.         HibernateSessionFactory.closeSession();  
  11.     }</strong></span>  
从上面的代码可以看出，clear方法可以管理一级缓存，一级缓存无法取消，但是可以管理，第一次执行load操作时会发出sql语句，接着由于一级缓存中的实体被清除了，因此第二次执行load操作时也会发出sql语句；

四，Hibernate中的第二级缓存

二级缓存是一个可插拔的缓存插件，它是由SessionFactory负责管理的；

由于SessionFactory对象的生命周期与应用程序的整个过程对应，通常一个应用程序对应一个SessionFactory，因此，二级缓存是进程范围或者集群范围的缓存；

与一级缓存一样，二级缓存也是根据对象的id来加载与缓存，当执行某个查询获得结果集为实体对象集时，hibernate就会把它们按照对象id加载到二级缓存中，在访问指定的id的对象时，首先从一级缓存中查找，找到就直接使用，找不到则转到二级缓存中查找(必须配置且启用二级缓存)，如果二级缓存中找到，则直接使用，否则会查询数据库，并将查询结果根据对象的id放到缓存中；

1，常用的二级缓存插件

Hibernate的二级缓存功能是通过配置二级缓存插件来实现的，常用的二级缓存插件包括EHCache，OSCache，SwarmCache和JBossCache。其中EHCache缓存插件是理想的进程范围的缓存实现，此处以使用EHCache缓存插件为例，来介绍如何使用hibernate的二级缓存；

2，Hibernate中使用EHCache的配置

1>引入EHCache相关的jar包；

lib\optional\ehcache下的三个jar包；

2>创建EHCache的配置文件ehcache.xml

[html] view plain copy
 print?
  1. <span style="font-size:18px;"><strong><ehcache>  
  2.     <diskStore path="java.io.tmpdir"/>  
  3.     <defaultCache  
  4.         maxElementsInMemory="10000"  
  5.         eternal="false"  
  6.         timeToIdleSeconds="120"  
  7.         timeToLiveSeconds="120"  
  8.         overflowToDisk="true"  
  9.         />  
  10.     <cache name="sampleCache1"  
  11.         maxElementsInMemory="10000"  
  12.         eternal="false"  
  13.         timeToIdleSeconds="300"  
  14.         timeToLiveSeconds="600"  
  15.         overflowToDisk="true"  
  16.         />  
  17.     <cache name="sampleCache2"  
  18.         maxElementsInMemory="1000"  
  19.         eternal="true"  
  20.         timeToIdleSeconds="0"  
  21.         timeToLiveSeconds="0"  
  22.         overflowToDisk="false"  
  23.         />  
  24. </ehcache></strong></span>  
在上述配置中，diskStore元素设置缓存数据文件的存储目录；defaultCache元素设置缓存的默认数据过期策略；cache元素设置具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域，命名缓存机制允许用户在每个类以及类的每个集合的粒度上设置数据过期策略；
在defaultCache元素中，maxElementsInMemory属性设置缓存对象的最大数目；eternal属性指定是否永不过期，true为不过期，false为过期；timeToldleSeconds属性设置对象处于空闲状态的最大秒数；timeToLiveSeconds属性设置对象处于缓存状态的最大秒数；overflowToDisk属性设置内存溢出时是否将溢出对象写入硬盘；

3>在Hibernate配置文件里面启用EHCache

在hibernate.cfg.xml配置文件中，启用EHCache的配置如下：

[html] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>                <!-- 启用二级缓存 -->  
  2.         <property name="hibernate.cache.use_second_level_cache">true</property>  
  3.         <!-- 设置二级缓存插件EHCache的Provider类 -->  
  4.         <property name="hibernate.cache.region.factory_class">  
  5.         org.hibernate.cache.ehcache.EhCacheRegionFactory</property></strong></span>  
4>配置哪些实体类的对象需要二级缓存，有两种方式：

1>>在实体类的映射文件里面配置

在需要进行缓存的持久化对象的映射文件中配置相应的二级缓存策略，如User,hbm.xml：

[html] view plain copy
 print?
  1. <span style="font-size:18px;"><strong><?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.hibtest1.entity.User" table="user" catalog="bookshop">  
  7.         <cache usage="read-write"/>  
  8.         <id name="id" type="java.lang.Integer">  
  9.             <column name="Id" />  
  10.             <generator class="native" />  
  11.         </id>  
  12.         <property name="loginName" type="java.lang.String">  
  13.             <column name="LoginName" length="50" />  
  14.         </property>  
  15.           
  16.     </class>  
  17. </hibernate-mapping></strong></span>  
映射文件中使用<cache>元素设置持久化类User的二级缓存并发访问策略，usage属性取值为read-only时表示只读型并发访问策略；read-write表示读写型并发访问策略；nonstrict-read-write表示非严格读写型并发访问策略；EHCache插件不支持transactional(事务型并发访问策略)。
注意：<cache>元素只能放在<class>元素的内部，而且必须处在<id>元素的前面，<cache>元素放在哪些<class>元素下面，就说明会对哪些类进行缓存；

2>>在hibernate配置文件中统一配置，强烈推荐使用这种方式：

在hibernate.cfg.xml文件中使用<class-cache>元素来配置哪些实体类的对象需要二级缓存：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong><span style="font-size:18px;"><strong><span style="font-size:18px;"><strong><class-cache usage="read-only" class="com.anlw.entity.Student"/></strong></span></strong></span></strong></span>  
在<class-cache>元素中，usage属性指定缓存策略，需要注意<class-cache>元素必须放在所有<mapping>元素的后面；

3，Hibernate中使用EHCache的测试：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public void Query(){  
  2.         Session sess1 = HibernateSessionFactory.getSession();  
  3.         Student s1 = (Student)sess1.get(Student.class, 1);  
  4.         System.out.println(s1.getName());  
  5.         HibernateSessionFactory.closeSession();  
  6.         Session sess2 = HibernateSessionFactory.getSession();  
  7.         Student s2 = (Student)sess2.get(Student.class, 1);  
  8.         System.out.println(s2.getName());  
  9.         HibernateSessionFactory.closeSession();  
  10.     }</strong></span>  
上面的代码，第一次执行get方法查询出结果后，关闭了session，一级缓存被清除了，由于配置并启用了二级缓存，查询出的结果会放入二级缓存，第二次执行get方法时，首先从一级缓存中查找，没有找到，然后转到二级缓存查找，二级缓存中找到结果，就不需要从数据库查询了。

注意：在hibernate配置二级缓存时属性的顺序如下，顺序错了会空指针异常：

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>                <!-- 启用二级缓存 -->  
  2.         <property name="hibernate.cache.use_second_level_cache">true</property>  
  3.         <!-- 设置二级缓存插件EHCache的Provider类 -->  
  4.         <property name="hibernate.cache.region.factory_class">  
  5.         org.hibernate.cache.ehcache.EhCacheRegionFactory</property>  
  6.         <mapping class="com.anlw.entity.Student"/>  
  7.         <class-cache usage="read-only" class="com.anlw.entity.Student"/></strong></span>  
先缓存配置，再mapping，最后calss-cache；

五，Hibernate中的查询缓存

对于经常使用的查询语句，如果启用了查询缓存 ，当第一次执行查询语句时，hibernate会将查询结果存储在二级缓存中，以后再次执行该查询语句时，从缓存中获取查询结果，从而提高查询性能；

hibernate的查询缓存主要是针对普通属性结果集的缓存，而对于实体对象的结果集只缓存id；

查询缓存的生命周期，若当前关联的表发生修改，那么查询缓存的生命周期结束；

1，查询缓存的配置

查询缓存基于二级缓存，使用查询缓存前，必须首先配置好二级缓存；

在配置了二级缓存的基础上，在hibernate的配置文件hibernate.cfg.xml中添加如下配置，可以启用查询缓存：

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

此外在程序中还必须手动启用查询缓存：

query.setCacheable(true);

2，测试查询缓存：

1>开启查询缓存，关闭二级缓存，开启一个session，分别调用query.list查询属性，测试前，先在先在hibernate.cfg.xml文件中开启查询缓存，关闭二级缓存，如下所示：

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

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>    public static void query(){  
  2.         Session sess = HibernateSessionFactory.getSession();  
  3.         Transaction tx = sess.beginTransaction();  
  4.         Query query = sess.createQuery("select s.name from Student s");  
  5.         query.setCacheable(true);  
  6.         List names = query.list();  
  7.         for(Iterator iter = names.iterator();iter.hasNext();){  
  8.             String name = (String)iter.next();  
  9.             System.out.println(name);  
  10.         }  
  11.         System.out.println("----------");  
  12.         query = sess.createQuery("select s.name from Student s");  
  13.         query.setCacheable(true);  
  14.         names = query.list();  
  15.         for(Iterator iter = names.iterator();iter.hasNext();){  
  16.             String name = (String)iter.next();  
  17.             System.out.println(name);  
  18.         }  
  19.         tx.commit();  
  20.         HibernateSessionFactory.closeSession();  
  21.     }  
  22. </strong></span>  

第二次没有去查数据库，因为启用了查询缓存；


2>开启查询缓存，关闭二级缓存，开启两个session，分别调用query.list查询属性，测试前，先在先在hibernate.cfg.xml文件中开启查询缓存，关闭二级缓存，如下所示：

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

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public static void query(){  
  2.         Session sess1 = HibernateSessionFactory.getSession();  
  3.         Transaction tx1 = sess1.beginTransaction();  
  4.         Query query = sess1.createQuery("select s.name from Student s");  
  5.         query.setCacheable(true);  
  6.         List names = query.list();  
  7.         for(Iterator iter = names.iterator();iter.hasNext();){  
  8.             String name = (String)iter.next();  
  9.             System.out.println(name);  
  10.         }  
  11.         tx1.commit();  
  12.         HibernateSessionFactory.closeSession();  
  13.         System.out.println("----------");  
  14.         Session sess2 = HibernateSessionFactory.getSession();  
  15.         Transaction tx2 = sess2.beginTransaction();  
  16.         query = sess2.createQuery("select s.name from Student s");  
  17.         query.setCacheable(true);  
  18.         names = query.list();  
  19.         for(Iterator iter = names.iterator();iter.hasNext();){  
  20.             String name = (String)iter.next();  
  21.             System.out.println(name);  
  22.         }  
  23.         tx2.commit();  
  24.         HibernateSessionFactory.closeSession();  
  25.     }</strong></span>  

第二次没有去查数据库，因为查询缓存生命周期与session生命周期无关；


3>开启查询缓存，关闭二级缓存，开启两个session，分别调用query.list查询实体对象，测试前，先在先在hibernate.cfg.xml文件中开启查询缓存，关闭二级缓存，如下所示：

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

[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>  public static void query(){  
  2.         Session sess1 = HibernateSessionFactory.getSession();  
  3.         Transaction tx1 = sess1.beginTransaction();  
  4.         Query query = sess1.createQuery("from Student");  
  5.         query.setCacheable(true);  
  6.         List student = query.list();  
  7.         for(Iterator iter = student.iterator();iter.hasNext();){  
  8.             Student s = (Student)iter.next();  
  9.             System.out.println(s.getName()+"--"+s.getAge());  
  10.         }  
  11.         tx1.commit();  
  12.         HibernateSessionFactory.closeSession();  
  13.         System.out.println("----------");  
  14.         Session sess2 = HibernateSessionFactory.getSession();  
  15.         Transaction tx2 = sess2.beginTransaction();  
  16.         query = sess2.createQuery("from Student");  
  17.         query.setCacheable(true);  
  18.         student = query.list();  
  19.         for(Iterator iter = student.iterator();iter.hasNext();){  
  20.             Student s = (Student)iter.next();  
  21.             System.out.println(s.getName()+"--"+s.getAge());  
  22.         }  
  23.         tx2.commit();  
  24.         HibernateSessionFactory.closeSession();  
  25.     }</strong></span>  
查询结果如下：
[java] view plain copy
 print?
  1. <span style="font-size:18px;"><strong>Hibernate:   
  2.     select  
  3.         student0_.id as id1_0_,  
  4.         student0_.age as age2_0_,  
  5.         student0_.name as name3_0_   
  6.     from  
  7.         student student0_  
  8. anliwenaaa--1  
  9. test--2  
  10. ----------  
  11. Hibernate:   
  12.     select  
  13.         student0_.id as id1_0_0_,  
  14.         student0_.age as age2_0_0_,  
  15.         student0_.name as name3_0_0_   
  16.     from  
  17.         student student0_   
  18.     where  
  19.         student0_.id=?  
  20. Hibernate:   
  21.     select  
  22.         student0_.id as id1_0_0_,  
  23.         student0_.age as age2_0_0_,  
  24.         student0_.name as name3_0_0_   
  25.     from  
  26.         student student0_   
  27.     where  
  28.         student0_.id=?  
  29. anliwenaaa--1  
  30. test--2</strong></span>  
第二次查询数据库时，会发出n条sql语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存会缓存实体对象的id，所以hibernate会根据实体对象的id去查询相应的实体，如果缓存中不存在相应的实体，那么将发出根据实体id查询的sql语句，否则不会发出sql，使用缓存中的数据；

4>开启查询缓存，开启二级缓存，开启两个session，分别调用query.list查询实体对象，测试前，先在先在hibernate.cfg.xml文件中开启查询缓存，开启二级缓存，如下所示：

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

代码和3>一样，但是结果不同，第二次不会发出sql，因为开启了二级缓存和缓存查询，查询缓存缓存了实体对象的id，hibernate会根据实体对象的id到二级缓存中取得相应的数据；
张润东
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Hibernate缓存详解
08-31
本文主要介绍了Hibernate缓存的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
细说Hibernate的缓存机制
孤鹰的博客
05-08 2135
2.1. 查询缓存：当使用 Session 对象执行查询操作时，如果一级缓存中没有数据，Hibernate 会在二级缓存中查找数据。2.2. 更新缓存：当使用 Session 对象执行更新操作时，Hibernate 会将更新后的数据存入一级缓存，并根据实体类的缓存策略更新二级缓存中的数据。2.3. 保存缓存：当使用 Session 对象执行保存操作时，Hibernate 会将新增的数据存入一级缓存，并根据实体类的缓存策略将数据插入到二级缓存。当 Session 对象被关闭时，一级缓存中的数据将被清除。
谈谈Hibernate的缓存
AlphaFinance
12-09 324
Hibernate支持两级缓存，一级缓存是Session级别的缓存，存储在Session对象中，可以减少数据库访问次数，提高性能。二、缓存机制不同：Session级别的缓存是基于强制依赖的，也就是说，如果某个对象在缓存中已经存在，并且某个其他对象依赖于该对象，那么在访问该其它对象时，必须先访问缓存中的对象，确保缓存中的对象始终是最新的。Session Factory级别的缓存是基于可选依赖的，也就是说，如果某个对象在缓存中已经存在，并且某个其它对象依赖于该对象，那么我们可以选择是否访问缓存中的对象。
Hibernate缓存(EhCache)
weixin_52457750的博客
10-16 665
Hibernate缓存(EhCache)
hibernate 的缓存理解
zuuzhang的专栏
09-11 600
  谈谈对HIBERNATE中缓存的理解：hibernate提供二级缓存机制。1.第一级缓存是session的缓存，由于session的生命周期是建立在一个数据库事务或者一个应用事务，因此这个缓存是事务范围的缓存。2.第二级缓存是一个可插拔的缓存插件，它由sessionfactory负责管理，由于sessionfactory的生命周期和应用程序的整个过程对应，因此二级缓存是进程或者集群范围
hibernate缓存深入详解.
08-09
关于hibernate缓存的一个ppt课件，60+幻灯片，有需要的可以看一下
Hibernate缓存深入详解
02-29
Hibernate缓存深入详解
Hibernate缓存深入详解 from ITEye
04-07
Hibernate 缓存 深入 详解 ITEye
spring boot+spring data jpa +ehcache 缓存配置
wwzuizz的博客
05-29 2309
pom.xml配置 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </depen...
Hibernate二级缓存以及查询缓存的配置步骤
Cyufeng的博客
04-15 238
　 　 　　 <defaultCache maxElementsInMemory=“10000”　　//在内存中存放的最大对象数 eternal=“false”　　　　　　　　　//是否永久保存缓存，设置成false timeToIdleSeconds=“120”　　　　 timeToLiveSeconds=“120”　　　　 overflowToDisk=“true”　　　　　/...
hibernate 缓存机制
林深不见鹿
04-15 2433
1. 一级缓存–session 在hibernate中，oid主键标识，当在session管理权限内，当第二次在使用某个对象时会从session 缓存中获取 2. 二级缓存—sessionFactory （1.） 内置缓存：hibernate自带的，不可卸载的，通常是在hibernate初始化阶段，hibernate会把映射元数据/预定于sql放到sessionFactory缓存中，内置缓存时只读的。 （2.）外置缓存：一个可以配置的缓存插件，可以由用户自定义配置选择缓存提供商，默认情况下sessionFa
Hibernate二级缓存
本是后山人
09-17 128
原文：Hibernate：缓存机制的学习 Hibernate中没有自己去实现二级缓存，而是利用第三方的。简单叙述一下配置过程，也作为自己以后用到的时候配置的一个参考。 1、我们需要加入额外的二级缓存包，例如EHcache，将其包导入。需要：ehcache-core-2.4.3.jar ， hibernate-ehcache-4.2.4.Final.jar ，slf4j-api-1.6.1.ja...
Hibernate+EhCache配置二级缓存
codepython的专栏
08-01 1021
Hibernate+EhCache配置二级缓存 作者: Michael 日期: 2012 年 4 月 26 日发表评论 (0)查看评论 本文主要讲一讲Hibernate+EhCache配置二级缓存的基本使用方法，主要分以下两个方面介绍： (有关EhCache的基础介绍可参见：http://www.micmiu.com/architecture/cache/ehca
hibernate的缓存
ryuhfxz的博客
08-23 140
一、一级缓存（session缓存）    很明显随session创建而存在随session消亡而结束（也可以说是事务级别的缓存，毕竟框架中几乎不需要自己开启session,一般随事务提交或者当前线程结束而结束)，一级缓存是针对持久态的数据，默认开启。    一级缓存的原理：     一级缓存有个副本（也叫快照区），获取数据每次都是先从缓存区取数据，缓存区没有数据才去查数据库（包括第一次获取数...
Hibernate关闭缓存，HQL子句
肖斌 的专栏
06-03 1155
applicationContext-aft-sso.xml..........删除内容 HQL条件查询:String hql =from TaclRoleuser userid="+userId+" and roleid="+roleId+";
hibernate,hql与sql的缓存使用
diquren的专栏
04-14 2870
1.在hibernate中createQuery执行hql查询的时候使用查询缓存：   getSession().createQuery(hql).setCacheable(true).setCacheRegion("user").list();  2.在hibernate中createSQLQuery执行sql时使用查询缓存：   getSession().createSQLQuery
Hibernate 使用createSQLQuery查询时，缓存问题
菜菜De学习
10-09 4947
Hibernate 使用createSQLQuery查询时，缓存问题 hibernate中 ，使用createSQLQuery（sql）查询，在开启getHibernateTemplate().setCacheQueries(true);后，执行到query.list();报异常：java.lang.ArrayIndexOutOfBoundsException: 0 当把关闭缓存getHi
Hibernate查询问题 如何不使用缓存 简单方法
热门推荐
vastskyjoe的专栏
01-07 1万+
如果 使用HIbernate循环查询某个表的话。他会使用缓存技术，来提高数据库性能。其思路是：第一次执行某个sql语句，记录下他的参数。第二次执行某个sql语句时候首先拿他的参数表和默认记录的参数表相比较，如果参数表一致，那么hibernate不会重新查询数据库，而是从缓存中读取他的值。因此连续执行某个查询语句的话，如果此时数据库中关于这个表的字段有更新，将不会显示。附：当两个sql语句完
hibernate redis缓存
最新发布
05-30
Hibernate Redis缓存是使用Redis作为Hibernate二级缓存的实现方式。它可以将Hibernate查询结果缓存到Redis中，从而提高系统性能和响应速度。 在使用Hibernate Redis缓存时，需要先配置Redis连接信息，然后在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值