`
yshao81710
  • 浏览: 94041 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Hibernate 缓存配置

阅读更多

 

hibernate一级缓存

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

那些方法支持一级缓存:

* get()

* load()

* iterate(查询实体对象)

如何管理一级缓存:

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

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

* 先flush,再clear

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

hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存,二级缓存可以被所有的session共享

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

二级缓存的配置和使用:

* 将echcache.xml文件拷贝到src下

* 开启二级缓存,修改hibernate.cfg.xml文件 放在<mapping>前

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

* 指定缓存产品提供商,修改hibernate.cfg.xml文件 放在<mapping>前

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

* 指定那些实体类使用二级缓存(两种方法)

   * 在映射文件中采用<cache>标签

   * 【推荐】在hibernate.cfg.xml文件中,采用<class-cache>标签 如: <class-cache class="com.bcm.model.Article" usage="read-write"/>

  

二级缓存是缓存实体对象的

hibernate查询缓存

查询缓存是针对普通属性结果集的缓存

对实体对象的结果集只缓存id

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

查询缓存的配置和使用:

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

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

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

query.setCacheable(true);

package com.bjsxt.hibernate;

import java.io.Serializable;

import java.util.Iterator;

import java.util.List;

import org.hibernate.CacheMode;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import junit.framework.TestCase;

public class CacheLevel2Test extends TestCase {

/**

* 开启查询缓存,关闭二级缓存

*

* 开启一个session,分别调用query.list

*/

public void testCache1() {

   Session session = null;

   try {

    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();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}

/**

* 开启查询缓存,关闭二级缓存

*

* 开启两个session,分别调用query.list

*/

public void testCache2() {

   Session session = null;

   try {

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

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

  

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

  

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

   //不会发出查询sql,因为查询缓存的生命周期和session无关

    List names = query.list();

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

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

     System.out.println(name);

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}  

/**

* 开启查询缓存,关闭二级缓存

*

* 开启两个session,分别调用query.iterate

*/

public void testCache3() {

   Session session = null;

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

    for (Iterator iter=query.iterate();iter.hasNext(); ) {

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

     System.out.println(name);

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

  

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

  

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

    //查询缓存只对query.list()起作用,query.iterate不起作用,也就是query.iterate不使用

    //查询缓存

    for (Iterator iter=query.iterate();iter.hasNext(); ) {

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

     System.out.println(name);

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}

/**

* 关闭查询缓存,关闭二级缓存

*

* 开启两个session,分别调用query.list查询实体对象

*/

public void testCache4() {

   Session session = null;

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    //query.setCacheable(true);

   

    List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

  

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

  

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    //query.setCacheable(true);

    //会发出查询sql,因为list默认每次都会发出查询sql

    List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}  

/**

* 开启查询缓存,关闭二级缓存

*

* 开启两个session,分别调用query.list查询实体对象

*/

public void testCache5() {

   Session session = null;

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

   List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

  

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

  

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

   //会发出n条查询语句,因为开启了查询缓存,关闭了二级缓存,那么查询缓存会缓存实体对象的id

    //所以hibernate会根据实体对象的id去查询相应的实体,如果缓存中不存在相应的

    //实体那么将发出根据实体id查询的sql语句,否则不会发出sql使用缓存中的数据

   List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}

/**

* 开启查询缓存,开启二级缓存

*

* 开启两个session,分别调用query.list查询实体对象

*/

public void testCache6() {

   Session session = null;

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

   List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

  

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

  

   try {

    session = HibernateUtils.getSession();

    session.beginTransaction();

   

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

    //启用查询查询缓存

    query.setCacheable(true);

   

   //不会发出查询sql,因为开启了二级缓存和查询缓存,查询缓存缓存了实体对象的id列表

    //hibernate会根据实体对象的id列表到二级缓存中取得相应的数据

    List students = query.list();

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

     Student student = (Student)iter.next();

     System.out.println(student.getName());

    }

    session.getTransaction().commit();

   }catch(Exception e) {

    e.printStackTrace();

    session.getTransaction().rollback();

   }finally {

    HibernateUtils.closeSession(session);

   }

}  

}

实体对象查询【重要】

* N + 1问题,在默认情况下(没有开通查询缓存),使用query.iterate查询,有可以能出现N+1问题

   所谓的N+1是在查询的时候发出了N+1条sql语句

   1: 首先发出一条查询对象id列表的sql

   N: 根据id列表到缓存中查询,如果缓存中不存在与之匹配的数据,那么会根据id发出相应的sql语句

* list和iterate的区别?

   * list每次都会发出sql语句,list会向缓存中放入数据,而不利用缓存中的数据

   * iterate:在默认情况下iterate利用缓存数据,但如果缓存中不存在数据有可以能出现N+1问题

无论list,load还是iterate,只要读出一个对象,都会填充缓存。但是list不会使用缓存,而iterate会先取数据库select id出来,然后一个id一个id的load,如果在缓存里面有,就从缓存取,没有的话就去数据库load

分享到:
评论

相关推荐

    深入理解Hibernate缓存

    理解Hibernate缓存的工作原理及配置方法对于提高应用性能具有重要意义。 在Hibernate中,缓存分为一级缓存(第一级缓存)和二级缓存(第二级缓存)。一级缓存是默认启用的,它存储在一个`Session`实例中,用于减少...

    Hibernate缓存深入详解 from ITEye

    Hibernate缓存可以针对实体类、集合类、SQL查询结果等设置不同的缓存区域。根据业务需求,可以自定义缓存策略,为不同类型的对象设置不同的缓存过期时间。 **六、缓存同步** 为了保证多线程环境下的数据一致性,...

    Hibernate缓存技术研究

    - **优化缓存配置**:例如设置合理的缓存过期时间、最大容量等参数,避免缓存占用过多内存。 - **监控缓存命中率**:定期检查缓存的命中率,调整缓存策略和配置,以达到最佳性能。 总之,Hibernate的缓存机制是提高...

    Hibernate二级缓存配置与分析

    学习hibernate的必备,提供一个简易的流程图,方便记忆和查找

    Hibernate缓存,性能优化

    - **二级缓存配置**:根据业务需求选择合适的缓存策略和过期机制,合理设置缓存区域,避免不必要的数据冗余和竞争,同时考虑数据一致性问题,确保缓存的有效性。 #### 优化查询和SQL语句 - **减少N+1查询问题**:...

    hibernate缓存机制

    Hibernate缓存机制是提高应用程序性能的关键技术之一,它通过存储数据副本减少对物理数据库的访问。缓存可以分为两层:第一级缓存和第二级缓存。 **第一级缓存**是内置在Session中的,它是不可卸载的,也称为...

    Hibernate缓存深入详解

    缓存配置和管理** 为了充分利用缓存,开发者需要根据实际需求进行适当的配置。例如,设置缓存的大小、过期策略、同步模式等。同时,需要注意缓存可能导致的数据一致性问题,尤其是在高并发环境中,合理地使用锁和...

    Spring集成的Hibernate配置二级缓存

    在企业级Java应用开发中,Spring和Hibernate是两个非常重要的框架。Spring作为一个全面的轻量级容器,负责管理对象的生命周期和依赖...通过优化缓存配置和策略,可以在不牺牲数据一致性的情况下,达到良好的用户体验。

    Hibernate缓存详解

    缓存配置 在Hibernate配置文件(hibernate.cfg.xml)中,可以设置二级缓存的相关参数,如开启二级缓存、指定缓存提供者、配置缓存区域等。例如: ```xml &lt;property name="hibernate.cache.use_second_level_cache...

    hibernate缓存

    #### 四、缓存配置与实现 为了实现Hibernate的缓存功能,需要进行以下步骤的配置: 1. **引入缓存组件**:例如使用EhCache作为二级缓存的实现,需要添加对应的jar包(如`ehcache.jar`)。 2. **配置缓存参数**:在...

    hibernate缓存和事务

    Hibernate 是一个流行的对象关系映射(ORM)框架,它允许Java...通过理解Hibernate缓存和事务管理,以及如何有效地执行查询,开发者可以创建高效、健壮的Java应用程序,降低与数据库交互的复杂性,同时提升系统性能。

    Hibernate缓存与spring事务详解

    **标题:“Hibernate缓存与Spring事务详解”** 在IT领域,尤其是Java开发中,Hibernate作为一款流行的ORM(对象关系映射)框架,极大地简化了数据库操作。而Spring框架则以其全面的功能,包括依赖注入、AOP(面向切...

    hibernate缓存策略

    #### 二、Hibernate缓存配置 ##### 2.1 概述 Hibernate的缓存机制分为两个层次:**一级缓存**和**二级缓存**。一级缓存是由Hibernate框架自动管理和维护的,它存在于每个Session的生命周期内;而二级缓存则需要...

    hibernate缓存ehcache用法

    这篇博客文章“hibernate缓存ehcache用法”可能详细介绍了如何在Hibernate中配置和使用Ehcache。 首先,我们需要理解什么是缓存。缓存是一种存储技术,用于临时保存经常访问的数据,以减少对主存储器(如数据库)的...

    hibernate一级和二级缓存配置与详解

    但是,可以通过设置`hibernate.cache.use_query_cache`来禁用查询缓存,防止对一级缓存造成影响。 ### 二级缓存 二级缓存是SessionFactory级别的,可以跨Session共享。相比一级缓存,二级缓存可以持久化存储,即使...

    Hibernate教程25_Hibernate缓存

    7. **示例代码**:通过提供的源码,我们可以学习如何在实际项目中配置和使用Hibernate缓存,包括创建缓存配置、声明缓存区域、启用查询缓存等。 总的来说,这个教程应该涵盖了Hibernate缓存的基础知识,包括一级...

    为Spring集成的Hibernate配置二级缓存

    在Java企业级开发中,Spring和Hibernate是两个非常...3. **配置Spring**:在Spring的配置文件(如`applicationContext.xml`)中,配置Hibernate SessionFactory,并注入二级缓存配置。以下是一个配置示例: ```xml ...

Global site tag (gtag.js) - Google Analytics