|
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中，缓存分为一级缓存（第一级缓存）和二级缓存（第二级缓存）。一级缓存是默认启用的，它存储在一个`Session`实例中，用于减少...
Hibernate缓存可以针对实体类、集合类、SQL查询结果等设置不同的缓存区域。根据业务需求，可以自定义缓存策略，为不同类型的对象设置不同的缓存过期时间。 **六、缓存同步** 为了保证多线程环境下的数据一致性，...
- **优化缓存配置**：例如设置合理的缓存过期时间、最大容量等参数，避免缓存占用过多内存。 - **监控缓存命中率**：定期检查缓存的命中率，调整缓存策略和配置，以达到最佳性能。 总之，Hibernate的缓存机制是提高...
学习hibernate的必备，提供一个简易的流程图，方便记忆和查找
- **二级缓存配置**：根据业务需求选择合适的缓存策略和过期机制，合理设置缓存区域，避免不必要的数据冗余和竞争，同时考虑数据一致性问题，确保缓存的有效性。 #### 优化查询和SQL语句 - **减少N+1查询问题**：...
Hibernate缓存机制是提高应用程序性能的关键技术之一，它通过存储数据副本减少对物理数据库的访问。缓存可以分为两层：第一级缓存和第二级缓存。 **第一级缓存**是内置在Session中的，它是不可卸载的，也称为...
缓存配置和管理** 为了充分利用缓存，开发者需要根据实际需求进行适当的配置。例如，设置缓存的大小、过期策略、同步模式等。同时，需要注意缓存可能导致的数据一致性问题，尤其是在高并发环境中，合理地使用锁和...
在企业级Java应用开发中，Spring和Hibernate是两个非常重要的框架。Spring作为一个全面的轻量级容器，负责管理对象的生命周期和依赖...通过优化缓存配置和策略，可以在不牺牲数据一致性的情况下，达到良好的用户体验。
缓存配置 在Hibernate配置文件（hibernate.cfg.xml）中，可以设置二级缓存的相关参数，如开启二级缓存、指定缓存提供者、配置缓存区域等。例如： ```xml <property name="hibernate.cache.use_second_level_cache...
#### 四、缓存配置与实现 为了实现Hibernate的缓存功能，需要进行以下步骤的配置： 1. **引入缓存组件**：例如使用EhCache作为二级缓存的实现，需要添加对应的jar包（如`ehcache.jar`）。 2. **配置缓存参数**：在...
Hibernate 是一个流行的对象关系映射（ORM）框架，它允许Java...通过理解Hibernate缓存和事务管理，以及如何有效地执行查询，开发者可以创建高效、健壮的Java应用程序，降低与数据库交互的复杂性，同时提升系统性能。
**标题：“Hibernate缓存与Spring事务详解”** 在IT领域，尤其是Java开发中，Hibernate作为一款流行的ORM（对象关系映射）框架，极大地简化了数据库操作。而Spring框架则以其全面的功能，包括依赖注入、AOP（面向切...
#### 二、Hibernate缓存配置 ##### 2.1 概述 Hibernate的缓存机制分为两个层次：**一级缓存**和**二级缓存**。一级缓存是由Hibernate框架自动管理和维护的，它存在于每个Session的生命周期内；而二级缓存则需要...
这篇博客文章“hibernate缓存ehcache用法”可能详细介绍了如何在Hibernate中配置和使用Ehcache。 首先，我们需要理解什么是缓存。缓存是一种存储技术，用于临时保存经常访问的数据，以减少对主存储器（如数据库）的...
但是，可以通过设置`hibernate.cache.use_query_cache`来禁用查询缓存，防止对一级缓存造成影响。 ### 二级缓存 二级缓存是SessionFactory级别的，可以跨Session共享。相比一级缓存，二级缓存可以持久化存储，即使...
7. **示例代码**：通过提供的源码，我们可以学习如何在实际项目中配置和使用Hibernate缓存，包括创建缓存配置、声明缓存区域、启用查询缓存等。 总的来说，这个教程应该涵盖了Hibernate缓存的基础知识，包括一级...
在Java企业级开发中，Spring和Hibernate是两个非常...3. **配置Spring**：在Spring的配置文件（如`applicationContext.xml`）中，配置Hibernate SessionFactory，并注入二级缓存配置。以下是一个配置示例： ```xml ...