AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

hibernate的查询缓存

2017-11-08 985
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
    在hibernate的使用中，大家多数时间都在讨论一级缓存和二级缓存，而往往忽略了查询缓存。其实hibernate的查询缓存在使用过程中也起着同样重要的作用。hibernate的查询缓存是主要是针对普通属性结果集的缓存， 而对于实体对象的结果集只缓存id。在一级缓存,二级缓存和查询缓存都打开的情况下作查询操作时这样的：查询普通属性，会先到查询缓存中取，如果没有，则查询数据库；查询实体，会先到查询缓存中取id，如果有，则根据id到缓存(一级/二级)中取实体，如果缓存中取不到实体，再查询数据库。
 
    和一级/二级缓存不同，查询缓存的生命周期 ，是不确定的，当前关联的表发生改变时，查询缓存的生命周期结束。
 
     查询缓存的配置和使用也是很简单的：
         1>查询缓存的启用不但要在配置文件中进行配置
             <property name="hibernate.cache.use_query_cache">true</property>
         2>还要在程序中显示的进行启用
             query.setCacheable(true);
 
1.实体类：
  Student.jsva
public  class Student { 
   private Integer id; 
   private String name; 
   //一系列的setter.getter方法 
}
 
2.映射文件
   Student.hbm.xml
   < class  name ="com.sxt.hibernate.cache.entity.Student"  table ="sxt_hibernate_student" > 
         
    <!--  指定本类的对象使用二级缓存(这也可以放在hibernate.cfg.xml中统一指定) --> 
    <!--  
    <cache usage="read-only"/> 
     --> 
     < id  name ="id"  length ="4" > 
       < generator  class ="native" > </ generator > 
     </ id > 
     < property  name ="name"  length ="10" > </ property > 
   </ class >
 
3.hibernate配置文件：
  hibernate.cfg.xml
< hibernate-configuration > 
   < session-factory > 
     < property  name ="hibernate.connection.url" >jdbc:oracle:thin:@localhost:1521:ORCL10 </ property > 
     < property  name ="hibernate.connection.driver_class" >oracle.jdbc.driver.OracleDriver </ property > 
     < property  name ="hibernate.connection.username" >scott </ property > 
     < property  name ="hibernate.connection.password" >yf123 </ property > 
     < property  name ="hibernate.dialect" >org.hibernate.dialect.Oracle9Dialect </ property > 
     < property  name ="hibernate.show_sql" >true </ property > 
     
    <!--  开启二级缓存,其实hibernate默认就是开启的,这里显示的指定一下 --> 
     < property  name ="hibernate.cache.use_second_level_cache" >true </ property > 
    <!--  指定二级缓存产品的提供商 --> 
     < property  name ="hibernate.cache.provider_class" >org.hibernate.cache.EhCacheProvider </ property > 
     
    <!--  启用查询缓存 --> 
     < property  name ="hibernate.cache.use_query_cache" >true </ property > 
     
     < mapping  resource ="com/sxt/hibernate/cache/entity/Student.hbm.xml" /> 
     
    <!--  指定那些类使用二级缓存 --> 
     < class-cache  usage ="read-only"  class ="com.sxt.hibernate.cache.entity.Student" /> 
   </ session-factory > 
</ hibernate-configuration >
 
4.测试方法：
   public  static  void main(String[] args) { 
    Session session =  null; 
    Transaction t =  null; 

    * //** 
     * 开启查询缓存,关闭二级缓存, 开启一个session,分别调用query.list 
     */ 
  //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
  /* 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      List<String> names = query.list(); 
      for (Iterator<String> it = names.iterator(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 
      System.out.println("================================"); 
      query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存 
      query.setCacheable(true); 
      //没有发出查询语句,因为这里使用的查询缓存 
      names = query.list(); 
      for (Iterator<String> it = names.iterator(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }*/ 
    
/*  @SuppressWarnings("unchecked") 
  public static void main(String[] args) { 
    Session session = null; 
    Transaction t = null; 

    *//** 
     * 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.list 
     *//* 
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存    
      //query.setCacheable(true); 
      List<String> names = query.list(); 
      for (Iterator<String> it = names.iterator(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 

      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
     
    System.out.println("================================"); 
     
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存    
      //query.setCacheable(true); 
      //不会发出查询语句,因为查询缓存和session无关. 
      List<String> names = query.list(); 
      for (Iterator<String> it = names.iterator(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }*/ 
    
/*  @SuppressWarnings("unchecked") 
  public static void main(String[] args) { 
    Session session = null; 
    Transaction t = null; 

    *//** 
     * 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.iterate 
     *//* 
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      for (Iterator<String> it = query.iterate(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
     
    System.out.println("================================"); 
     
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s.name from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      //会发出查询语句,因为query.iterate不使用查询缓存 
      for (Iterator<String> it = query.iterate(); it.hasNext();) { 
        String name = it.next(); 
        System.out.println(name); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }*/ 
    
/*    @SuppressWarnings("unchecked") 
  public static void main(String[] args) { 
    Session session = null; 
    Transaction t = null; 

    *//** 
     * 关闭查询缓存,关闭二级缓存, 开启两个session,分别调用query.list查询实体对象 
     *//* 
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      //query.setCacheable(true); 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
     
    System.out.println("================================"); 
     
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      //query.setCacheable(true); 
      //会发出查询语句,因为list默认每次都会发出sql语句 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }*/ 
    
/*  @SuppressWarnings("unchecked") 
  public static void main(String[] args) { 
    Session session = null; 
    Transaction t = null; 

    *//** 
     * 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.list查询实体对象 
     *//* 
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
     
    System.out.println("================================"); 
     
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      //会发出根据id查询实体的n条查询语句,因为这种情况下,查询过程是这样的： 
      // 在第一次执行list时,会把查询对象的id缓存到查询缓存里 
      // 第二次执行list时, 会遍历查询缓存里的id到缓存里去找实体对象,由于这里没找到实体对象, 
      //所以就发出n条查询语句到数据库中查询. 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }*/ 
    
  @SuppressWarnings("unchecked") 
  public static void main(String[] args) { 
    Session session = null; 
    Transaction t = null; 

    /** 
     * 开启查询缓存,开启二级缓存, 开启两个session,分别调用query.list查询实体对象 
     */ 
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况. 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
     
    System.out.println("================================"); 
     
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Query query = session.createQuery("select s from Student s"); 
      //启用查询缓存    
      query.setCacheable(true); 
      //不会发出查询语句,因为这种情况下,查询过程是这样的： 
      // 在第一次执行list时,会把查询对象的id缓存到查询缓存里 
      // 第二次执行list时, 会遍历查询缓存里的id到缓存里去找实体对象,由于这里开启了二级缓存,可以找到目标实体对象, 
      //所以就不会再发出n条查询语句. 
      List<Student> students = query.list(); 
      for (Iterator<Student> it = students.iterator(); it.hasNext();) { 
        Student s = it.next(); 
        System.out.println(s.getName()); 
      } 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
  }



     本文转自NightWolves 51CTO博客，原文链接： http://blog.51cto.com/yangfei520/287380 ，如需转载请自行联系原作者

文章标签：
缓存
Java
数据库连接
数据库
SQL
关系型数据库
Oracle
关键词：
查询缓存
Hibernate缓存
Hibernate查询
hibernate查询缓存
技术小胖子
目录
相关文章
艾伦~耶格尔
|
7月前
|
SQL 缓存 监控
MySQL缓存机制：查询缓存与缓冲池优化
MySQL缓存机制是提升数据库性能的关键。本文深入解析了MySQL的缓存体系，包括已弃用的查询缓存和核心的InnoDB缓冲池，帮助理解缓存优化原理。通过合理配置，可显著提升数据库性能，甚至达到10倍以上的效果。
艾伦~耶格尔
524 1
varin
|
7月前
|
存储 缓存 NoSQL
Redis专题-实战篇二-商户查询缓存
本文介绍了缓存的基本概念、应用场景及实现方式，涵盖Redis缓存设计、缓存更新策略、缓存穿透问题及其解决方案。重点讲解了缓存空对象与布隆过滤器的使用，并通过代码示例演示了商铺查询的缓存优化实践。
varin
318 1
Redis专题-实战篇二-商户查询缓存
瓴羊QuickBI小助手
|
11月前
|
缓存 数据挖掘 BI
【产品小贴士】: Quick引擎之查询缓存
Quick引擎之查询缓存
瓴羊QuickBI小助手
307 27
1445023846
|
缓存 NoSQL 关系型数据库
WordPress数据库查询缓存插件
这款插件通过将MySQL查询结果缓存至文件、Redis或Memcached，加速页面加载。它专为未登录用户优化，支持跨页面缓存，不影响其他功能，且可与其他缓存插件兼容。相比传统页面缓存，它仅缓存数据库查询结果，保留动态功能如阅读量更新。提供三种缓存方式选择，有效提升网站性能。
1445023846
274 1
Dylaniou
|
存储 缓存 索引
从底层数据结构和CPU缓存两方面剖析LinkedList的查询效率为什么比ArrayList低
本文详细对比了ArrayList和LinkedList的查询效率，从底层数据结构和CPU缓存两个方面进行分析。ArrayList基于动态数组，支持随机访问，查询时间复杂度为O(1)，且CPU缓存对其友好；而LinkedList基于双向链表，需要逐个节点遍历，查询时间复杂度为O(n)，且CPU缓存对其帮助不大。文章还探讨了CPU缓存对数组增删操作的影响，指出缓存主要作用于读取而非修改。通过这些分析，加深了对这两种数据结构的理解。
Dylaniou
303 2
土木林森
|
缓存 NoSQL Java
揭秘性能提升的超级武器：掌握Hibernate二级缓存策略！
【9月更文挑战第3天】在软件开发中，性能优化至关重要。使用Hibernate进行数据持久化的应用可通过二级缓存提升数据访问速度。一级缓存随Session生命周期变化，而二级缓存是SessionFactory级别的全局缓存，能显著减少数据库访问次数，提高性能。要启用二级缓存，需在映射文件或实体类上添加相应配置。然而，并非所有场景都适合使用二级缓存，需根据业务需求和数据变更频率决定。此外，还可与EhCache、Redis等第三方缓存集成，进一步增强缓存效果。合理运用二级缓存策略，有助于大幅提升应用性能。
土木林森
371 5
土木林森
|
API Java 数据库连接
从平凡到卓越：Hibernate Criteria API 让你的数据库查询瞬间高大上，彻底告别复杂SQL！
【8月更文挑战第31天】构建复杂查询是数据库应用开发中的常见需求。Hibernate 的 Criteria API 以其强大和灵活的特点，允许开发者以面向对象的方式构建查询逻辑，同时具备 SQL 的表达力。本文将介绍 Criteria API 的基本用法并通过示例展示其实际应用。此 API 通过 API 构建查询条件而非直接编写查询语句，提高了代码的可读性和安全性。无论是简单的条件过滤还是复杂的分页和连接查询，Criteria API 均能胜任，有助于提升开发效率和应用的健壮性。
土木林森
557 0
1603458909890196
|
存储 缓存 NoSQL
微服务复杂查询之缓存策略
微服务复杂查询之缓存策略
1603458909890196
135 0
土木林森
|
缓存 关系型数据库 MySQL
【缓存大对决】Memcached VS MySQL查询缓存，谁才是真正的性能之王？
【8月更文挑战第24天】在现代Web应用中，缓存技术对于提升性能与响应速度至关重要。本文对比分析了Memcached与MySQL查询缓存这两种常用方案。Memcached是一款高性能分布式内存对象缓存系统，支持跨服务器共享缓存，具备灵活性与容错性，但受限于内存大小且不支持数据持久化。MySQL查询缓存内置在MySQL服务器中，简化了缓存管理，特别适用于重复查询，但功能较为单一且扩展性有限。两者各有所长，实际应用中可根据需求单独或结合使用，实现最佳性能优化。
土木林森
541 0
wljslmz
|
SQL Java 数据库连接
SQL 和 HQL（Hibernate 查询语言）有什么区别？
【8月更文挑战第21天】
wljslmz
1504 0