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);
}
}
}
分享到：
相关推荐
本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存，通过具体的实例来阐述它们的工作原理和使用方法。 首先，我们从一级缓存开始。一级缓存是Hibernate默认提供的缓存，它是每个Session级别的，也被称为...
在深入探讨Hibernate查询缓存之前，我们先了解一下Hibernate的基础概念。Hibernate是一个强大的Java持久化框架，它简化了数据库操作，提供了对象关系映射（ORM）功能。在Hibernate中，对象的状态分为瞬时态、持久态...
【标题】：“Hibernate查询缓存及实现.PPT” 【描述】：“Hibernate查询缓存及实现.PPT” 在本文中，我们将深入探讨Hibernate框架中的查询缓存机制及其实施步骤，这是一项旨在提高应用程序性能的重要功能。查询...
**hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中，缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数，提高数据读取速度，并且在一定程度上降低了系统的负载。本文将...
这意味着在同一个Session内，对同一对象的多次读取和写入都会在缓存内完成，无需重复查询数据库。每个持久化类实例都有唯一的OID（对象标识符），确保了数据的唯一性。当事务结束时，Session会将所有未提交的更改...
文档"Hibernate_二级缓存总结 开发技术 - Java.doc"可能详细阐述了如何配置和使用Hibernate的二级缓存，包括配置文件的设置、缓存提供者的选用、实体和集合的缓存配置，以及实战中的优化技巧。阅读该文档将有助于...
总的来说，尽管Hibernate的使用场景可能不像过去那么广泛，但其提供的对象关系映射、缓存机制和查询优化策略仍然是理解现代数据库操作和Java开发中的宝贵知识。了解并掌握这些技术，可以帮助开发者编写出更高效、更...
缓存中存储的是数据库数据的副本，当需要查询数据时，Hibernate会首先在缓存中查找，如果找到，就直接返回，避免了数据库查询的开销。 **1. Hibernate缓存概述** Hibernate提供了两级缓存：一级缓存和二级缓存。一...
总结来说，Hibernate的二级缓存和查询缓存是提升性能的重要手段，但正确配置和使用它们至关重要，以免带来不必要的性能损失。通过合理的缓存策略和配置，可以有效地减少数据库交互，提升应用的响应速度。
在 Hibernate 中，二级缓存和查询缓存是提高应用性能的重要机制。下面将详细介绍如何开启并理解这两个缓存机制。 ### 1. 一级缓存与二级缓存 #### 1.1 一级缓存 一级缓存是 Hibernate 内置的 Session 缓存，它是每...
### Hibernate缓存技术研究 #### 一、引言 Hibernate是一种强大的对象-关系映射（Object-Relational Mapping，简称ORM）工具，主要用于Java环境下的应用程序。它能够将应用程序中的对象模型映射到关系型数据库的表...
管理Hibernate的缓存缓存 管理Hibernate的缓存缓存
**标题：“Hibernate的缓存机制”** 在Java的持久化框架Hibernate中，缓存机制扮演着至关重要的角色，它能够显著提升数据访问的性能。缓存可以分为一级缓存和二级缓存，以及查询缓存。 **一级缓存**： 一级缓存是...
Hibernate缓存可以针对实体类、集合类、SQL查询结果等设置不同的缓存区域。根据业务需求，可以自定义缓存策略，为不同类型的对象设置不同的缓存过期时间。 **六、缓存同步** 为了保证多线程环境下的数据一致性，...
综上所述，Hibernate缓存机制是提升应用性能的重要手段，通过合理配置缓存策略、优化查询方式、管理数据库连接以及实施有效的监控和调优措施，可以显著提高Hibernate应用的运行效率和用户体验。然而，缓存的使用并非...
当同样的查询被执行多次时，Hibernate会首先查看查询缓存，如果缓存中有结果，则直接返回，无需再次执行SQL。不过，查询缓存对数据一致性要求较高，一旦数据更新，可能需要清理相关查询结果的缓存。 接下来，我们...
这种实现方式使得在后续查询相同ID时可以直接从缓存中获取，避免了数据库的再次查询。 #### 五、二级缓存的实现细节 - **外置缓存的实现**：由于二级缓存是可配置的，因此可以根据具体需求选择不同的实现方案。...
如果启用查询缓存，还需添加`hibernate.cache.use_query_cache=true`。 二级缓存将数据视为一个Map，Key通常是实体的ID，Value是对应的实体对象。对于实体的读取，无论是通过list、load还是iterate，只要读取到一个...