一级与二级缓存只能缓存实体对象，查询缓存可以缓存查询的结果集，即可以缓存普通的属性.
注意：只有经常使用同样参数的查询才能获得好处，查询缓存的生命周期直到属性被修改了为止
注意：查询缓存对实体对象的结果集只缓存id
查询缓存的配置与使用：
<!-- 开启查询缓存，默认是关闭的 -->
<property name="hibernate.cache.use_query_cache">true</property>
在程序中应开启：
Query query = session.createQuery("select s.name from Student s");
query.setCacheable(true);//开启查询缓存
测试比较
package myHibernate;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import myHibernate.HibernateUtils;
import myHibernate.Student;
import org.hibernate.CacheMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import junit.framework.TestCase;
/**
* 2010年4月23日 21:26:17 查询缓存测试
* */
public class QueryCacheTest extends TestCase {
public void testCache1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
query.setCacheable(false);
List names = query.list();
for (Iterator iter = names.iterator(); iter.hasNext();) {
String name = (String) iter.next();
System.out.println(name);
}
System.out.println("-------------------------");
// 会发出SQL语句，因为没有使用查询缓存
query = session.createQuery("select s.name from Student s");
query.setCacheable(false);
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用 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);
}
System.out.println("-------------------------");
// 不会会发出SQL语句，因为启用查询缓存
query = session.createQuery("select s.name from Student s");
// 启用了查询缓存
query.setCacheable(true);
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用 list进行查询
*/
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);
List names = query.list();
for (Iterator iter = names.iterator(); iter.hasNext();) {
String name = (String) iter.next();
System.out.println(name);
}
System.out.println("-------------------------");
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
// 第二个session
try {
session = HibernateUtils.getSession();
session.beginTransaction();
// 不会发出SQL语句，因为查询缓存与session无关，可以跨session
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);
}
}
// 开启查询缓存，但这次使用的不是query的list接口而是iterate接口
public void testCache4() {
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);
}
System.out.println("-------------------------");
// 会发出SQL语句，因为查询缓存只对query.list()起作用，也就是query.iterate()不使用查询缓存
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);
}
}
// 开启查询缓存，关闭二级缓存，跨session查询实体对象
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 s = (Student) iter.next();
System.out.println(s.getName());
}
System.out.println("-------------------------");
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
// 第二个session
try {
session = HibernateUtils.getSession();
session.beginTransaction();
// 会发出N条查询语句，因为查询缓存会缓存实体对象的id,所以hibernate会根据实体对象
// 的id去查询对应的实体，如果缓存中不存在对应的实体那么会根据实体的id去查询实体，
// 如果有相应的实体则不会发出sql
Query query = session.createQuery("select s from Student s");
query.setCacheable(true);
List students = query.list();
for (Iterator iter = students.iterator(); iter.hasNext();) {
Student s = (Student) iter.next();
System.out.println(s.getName());
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
// 开启查询缓存，开启二级缓存，跨session查询实体对象
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 s = (Student) iter.next();
System.out.println(s.getName());
}
System.out.println("-------------------------");
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
// 第二个session
try {
session = HibernateUtils.getSession();
session.beginTransaction();
// 不会发出sql，因为开启了二级缓存，查询缓存缓存了实体对象的id
// hibernate会根据实体对象的id列表到二级缓存中取得相应的数据
Query query = session.createQuery("select s from Student s");
query.setCacheable(true);
List students = query.list();
for (Iterator iter = students.iterator(); iter.hasNext();) {
Student s = (Student) iter.next();
System.out.println(s.getName());
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
}
分享到：
相关推荐
在深入探讨Hibernate查询缓存之前，我们先了解一下Hibernate的基础概念。Hibernate是一个强大的Java持久化框架，它简化了数据库操作，提供了对象关系映射（ORM）功能。在Hibernate中，对象的状态分为瞬时态、持久态...
【标题】：“Hibernate查询缓存及实现.PPT” 【描述】：“Hibernate查询缓存及实现.PPT” 在本文中，我们将深入探讨Hibernate框架中的查询缓存机制及其实施步骤，这是一项旨在提高应用程序性能的重要功能。查询...
本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存，通过具体的实例来阐述它们的工作原理和使用方法。 首先，我们从一级缓存开始。一级缓存是Hibernate默认提供的缓存，它是每个Session级别的，也被称为...
文档"Hibernate_二级缓存总结 开发技术 - Java.doc"可能详细阐述了如何配置和使用Hibernate的二级缓存，包括配置文件的设置、缓存提供者的选用、实体和集合的缓存配置，以及实战中的优化技巧。阅读该文档将有助于...
**hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中，缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数，提高数据读取速度，并且在一定程度上降低了系统的负载。本文将...
Hibernate的查询缓存是建立在第二级缓存的基础上的，它缓存的是查询结果，而不是对象本身。当一个查询被执行并且其结果被缓存后，如果同样的查询再次被执行，Hibernate将直接从缓存中获取结果，而不需要重新执行SQL...
## Hibernate缓存机制详解 ### 一、缓存分类与管理 Hibernate提供了两种主要的缓存类型：一级缓存和二级缓存。 #### 1. 一级缓存 一级缓存也称为Session缓存，它在同一个Session中对数据的多次读取操作只需要一...
总结，Hibernate缓存机制是其性能优化的重要手段，通过理解并合理利用一级缓存、二级缓存和查询缓存，能够显著提升应用的运行效率。然而，缓存的使用也需谨慎，以免引发数据一致性问题。开发者应结合实际业务场景，...
Hibernate查询首先介绍get()和load()方法的区别:get()方法和load()方法的区别主要在于对二级缓存的使用上。load()方法会使用二级缓存，而get()方法在一级缓存没有找到会直接查询数据库，不会去二级缓存中查找。 get...
Hibernate缓存机制是提高应用程序性能的关键特性，尤其是在频繁与数据库交互的应用中。缓存通过减少对物理数据库的直接访问次数，显著提升了数据读取和写入的速度。这主要是因为从缓存中读取数据比从数据库中获取更...
总的来说，尽管Hibernate的使用场景可能不像过去那么广泛，但其提供的对象关系映射、缓存机制和查询优化策略仍然是理解现代数据库操作和Java开发中的宝贵知识。了解并掌握这些技术，可以帮助开发者编写出更高效、更...
【Hibernate缓存深入详解】 在Java的持久化框架Hibernate中，缓存机制是提升系统性能的关键因素。它位于Hibernate应用和数据库之间，减少了对数据库的直接访问，从而提高了应用程序的运行速度。缓存中存储的是...
总结来说，Hibernate的二级缓存和查询缓存是提升性能的重要手段，但正确配置和使用它们至关重要，以免带来不必要的性能损失。通过合理的缓存策略和配置，可以有效地减少数据库交互，提升应用的响应速度。
在 Hibernate 中，二级缓存和查询缓存是提高应用性能的重要机制。下面将详细介绍如何开启并理解这两个缓存机制。 ### 1. 一级缓存与二级缓存 #### 1.1 一级缓存 一级缓存是 Hibernate 内置的 Session 缓存，它是每...
### Hibernate缓存技术研究 #### 一、引言 Hibernate是一种强大的对象-关系映射（Object-Relational Mapping，简称ORM）工具，主要用于Java环境下的应用程序。它能够将应用程序中的对象模型映射到关系型数据库的表...
管理Hibernate的缓存缓存 管理Hibernate的缓存缓存
Hibernate缓存可以针对实体类、集合类、SQL查询结果等设置不同的缓存区域。根据业务需求，可以自定义缓存策略，为不同类型的对象设置不同的缓存过期时间。 **六、缓存同步** 为了保证多线程环境下的数据一致性，...
综上所述，Hibernate缓存机制是提升应用性能的重要手段，通过合理配置缓存策略、优化查询方式、管理数据库连接以及实施有效的监控和调优措施，可以显著提高Hibernate应用的运行效率和用户体验。然而，缓存的使用并非...