- 浏览: 363173 次
- 性别:
- 来自: 广东珠海
文章分类
最新评论
-
cuiyijing:
[size=small]马士兵 26_homework_dml ...
SQL面试题 -
utobe:
兄弟 你真的出名了,尚学堂 oracle 马士兵的视频拿你的题 ...
SQL面试题 -
tlqtangok:
没看懂,能解释一下吗?
安装Oracle后java的jvm会报错 -
a114d:
itling 写道尚学堂的demo楼上威武
hibernate 全面学习【hibernate抓取策略 】 -
wohenshuaiba:
不错,但是没写return checkimg( this ); ...
图片上传
hibernate 缓存分为一级缓存和二级缓存,及查询缓存
hinbernate 一级缓存
1、一级缓存很短,和session的生命周期一致,随着session的关闭而消失
*load/get/iterate(查询实体对象)可以使用缓存数据
2、一级缓存它缓存的是实体对象
3、如果管理缓存,如session.clear()/session.evict()
4、如何避免一次性大批量实体数据插入内存溢出的问题?
*先执行flush,在用clear清除缓存
hibernate 二级缓存
定义步骤:
1、打开缓存,在hibernate.cfg.xm中加入:
<property name="hibernate.cache.use_second_level_cache">true</property>
2、指定缓存策略提供商,在hibernate.cfg.xm中加入:
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
3、拷贝echcahe.xml到src下,可以针对不同的策略配置缓存
4、指定那些类使用缓存(两种方式)
* 在hibernate.cfg.xml
* 在映射文件中
二级缓存中存储的也是实体对象,他们都属于SessionFactory级别,
是全局的,伴随SessionFactory的生命周期存在和消亡
需要了解一级缓存和二级缓存的交互模式(CacheMode)
hibernate查询缓存
配置:
在hibernate.cfg.xml文件中加入:<property name="hibernate.cache.use_query_cache">true</property>
1、针对普通属性结果集的缓存
2、对是实体对象的结果集,只缓存id
3、使用查询缓存,需要打开查询缓存,并且在调用list方法之前需要显示的调用query.setCacheable(true);
一级缓存
二级缓存测试
查询缓存
hinbernate 一级缓存
1、一级缓存很短,和session的生命周期一致,随着session的关闭而消失
*load/get/iterate(查询实体对象)可以使用缓存数据
2、一级缓存它缓存的是实体对象
3、如果管理缓存,如session.clear()/session.evict()
4、如何避免一次性大批量实体数据插入内存溢出的问题?
*先执行flush,在用clear清除缓存
hibernate 二级缓存
定义步骤:
1、打开缓存,在hibernate.cfg.xm中加入:
<property name="hibernate.cache.use_second_level_cache">true</property>
2、指定缓存策略提供商,在hibernate.cfg.xm中加入:
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
3、拷贝echcahe.xml到src下,可以针对不同的策略配置缓存
4、指定那些类使用缓存(两种方式)
* 在hibernate.cfg.xml
* 在映射文件中
二级缓存中存储的也是实体对象,他们都属于SessionFactory级别,
是全局的,伴随SessionFactory的生命周期存在和消亡
需要了解一级缓存和二级缓存的交互模式(CacheMode)
hibernate查询缓存
配置:
在hibernate.cfg.xml文件中加入:<property name="hibernate.cache.use_query_cache">true</property>
1、针对普通属性结果集的缓存
2、对是实体对象的结果集,只缓存id
3、使用查询缓存,需要打开查询缓存,并且在调用list方法之前需要显示的调用query.setCacheable(true);
一级缓存
import java.io.Serializable; import org.hibernate.Session; import junit.framework.TestCase; public class CacheLevel1Test extends TestCase { /** * 发出两次load查询 * */ public void testCache1() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); //因为有一级缓存,load方法使用一级缓存,所以本次查询不再发出sql student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 发出两次get查询 * */ public void testCache2() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.get(Student.class, 1); System.out.println("学生姓名:" + student.getName()); //因为有一级缓存,get方法使用一级缓存,所以本次查询不再发出sql student = (Student)session.get(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 发出两次iterate查询实体对象 * */ public void testCache3() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.createQuery("from Student where id=1").iterate().next(); System.out.println("学生姓名:" + student.getName()); //因为有一级缓存,iterate方法使用一级缓存,发出查询id的sql,不再发出查询实体对象的sql student = (Student)session.createQuery("from Student where id=1").iterate().next(); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 发出两次iterate查询普通属性 * */ public void testCache4() { Session session = null; try { session = HibernateUtils.getSession(); String name = (String)session.createQuery("select name from Student where id=1").iterate().next(); System.out.println("学生姓名:" + name); //Iterate查询普通结果集,一级缓存不会缓存,它也不会发出查询id的sql name = (String)session.createQuery("select name from Student where id=1").iterate().next(); System.out.println("学生姓名:" + name); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 打开两次session,调用load测试 * */ public void testCache5() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //打开第二个session try { session = HibernateUtils.getSession(); //会发出sql,session间是不能共享一级缓存数据的 //因为它会伴随session的生命周期存在和消亡 Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 先执行save,再执行load进行测试 * */ public void testCache6() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); Student student = new Student(); student.setName("张三"); Serializable id = session.save(student); //因为save会将实体对象的数据缓存到session中 //所以再次查询相同数据,不会发出sql Student newStudent = (Student)session.load(Student.class, id); System.out.println("学生姓名:" + newStudent.getName()); session.getTransaction().commit(); }catch(Exception e) { e.printStackTrace(); session.getTransaction().rollback(); }finally { HibernateUtils.closeSession(session); } } /** * 执行session.clear()或session.evict()方法后,再调用load */ public void testCache7() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); //管理session缓存(一级缓存机制无法取消的,但可以管理缓存,如:clear,evict方法) session.evict(student); //session.clear(); //发出sql,因为缓存中的student实体类,已经被逐出 student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 向数据库中插入10000学生数据 * */ public void testCache8() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); for (int i = 0; i < 10000; i++) { Student student = new Student(); student.setName("Student_" + i); session.save(student); //每100条数据就强制session将数据持久化 //同时清空缓存,以避免在大量的数据下,造成内存溢出 if ( i % 100 == 0) { session.flush(); session.clear(); } } session.getTransaction().commit(); }catch(Exception e) { e.printStackTrace(); session.getTransaction().rollback(); }finally { HibernateUtils.closeSession(session); } } }
二级缓存测试
package com.bjsxt.hibernate; import java.io.Serializable; import org.hibernate.CacheMode; import org.hibernate.Session; import org.hibernate.SessionFactory; import junit.framework.TestCase; public class CacheLevel2Test extends TestCase { /** * 打开两次session,调用load测试 * */ public void testCache1() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //打开第二个session try { session = HibernateUtils.getSession(); //因为打开了二级缓存,所以本次查询不会发出sql Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 调用了次load,第一次调用完成后,清除sessionFactory中的二级缓存数据, * 再开启一个session,调用load * */ public void testCache2() { Session session = null; try { session = HibernateUtils.getSession(); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //管理二级缓存 SessionFactory factory = HibernateUtils.getSessionFactory(); factory.evict(Student.class); //打开第二个session try { session = HibernateUtils.getSession(); //因为二级缓存已经被清空,所以本次查询将发出一条新的sql Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 调用了次load,第一次调用完成后,清除sessionFactory中的二级缓存数据, * 再开启一个session,调用load * */ public void testCache3() { Session session = null; try { session = HibernateUtils.getSession(); //GET的CahceMode,使得session指会从sessionFactory中获取数据 //而不向其中添加数据 session.setCacheMode(CacheMode.GET); Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //打开第二个session try { session = HibernateUtils.getSession(); //因为二级缓存中没有数据,所以发出sql Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //打开第三个session try { session = HibernateUtils.getSession(); session.setCacheMode(CacheMode.PUT); //不会读数据,所以发出sql Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } //打开第四个session try { session = HibernateUtils.getSession(); //不会发出sql Student student = (Student)session.load(Student.class, 1); System.out.println("学生姓名:" + student.getName()); }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } }
查询缓存
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 QueryCacheTest extends TestCase { /** * 执行两次query * */ public void testCache1() { Session session = null; try { session = HibernateUtils.getSession(); 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); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 执行两次query,第二个query新open一个session * */ public void testCache2() { Session session = null; try { session = HibernateUtils.getSession(); 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); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } try { session = HibernateUtils.getSession(); System.out.println("----------------------------------------------------"); //不再发出sql,因为查询缓存的生命周期和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); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 采用query.iterate测试 * */ public void testCache3() { Session session = null; try { session = HibernateUtils.getSession(); Query query = session.createQuery("select s.name from Student s"); query.setCacheable(true); Iterator iter = query.iterate(); while (iter.hasNext()) { String name = (String)iter.next(); System.out.println(name); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } try { System.out.println("----------------------------------------------------------"); session = HibernateUtils.getSession(); Query query = session.createQuery("select s.name from Student s"); query.setCacheable(true); //query.iterate()操作不会使用查询缓存 //!!!查询缓存只对query.list()操作有效! Iterator iter = query.iterate(); while (iter.hasNext()) { String name = (String)iter.next(); System.out.println(name); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } } /** * 1、使用查询缓存 * 2、查询实体对象数据 * 3、把二级缓存关闭 * */ public void testCache4() { Session session = null; try { session = HibernateUtils.getSession(); 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()); } System.out.println("-------------------------------------------------"); query = session.createQuery("select s from Student s"); query.setCacheable(true); students = query.list(); for (Iterator iter = students.iterator(); iter.hasNext();) { Student student = (Student)iter.next(); System.out.println(student.getName()); } }catch(Exception e) { e.printStackTrace(); }finally { HibernateUtils.closeSession(session); } // try { // System.out.println("-------------------------------------------------"); // session = HibernateUtils.getSession(); // //将会发出n条查询语句,因为二级缓存被关闭,而查询缓存中的数据只是实体对象的id // //list操作会根据这些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 student = (Student)iter.next(); // System.out.println(student.getName()); // } // }catch(Exception e) { // e.printStackTrace(); // }finally { // HibernateUtils.closeSession(session); // } } }
发表评论
-
hibernate
2012-05-14 14:27 0<?xml version="1.0" ... -
hibernate 全面学习->hibernate 关联映射学习
2008-07-04 16:26 4900hibernate 关联映射学习包括 一对一,一对多,多对多 ... -
hibernate 全面学习【hibernate session学习】
2008-07-04 16:16 2204测试对象的生命周期: ... -
hibernate 全面学习【悲观锁和乐观锁 学习】
2008-07-04 16:12 1542乐观锁: 大多数基于数据版本(version)记录机制实现,一 ... -
hibernate 全面学习【lazy策略 】
2008-07-04 15:58 7131lazy策略可以用在: * <class>标签 ... -
hibernate 全面学习【hibernate抓取策略 】
2008-07-04 15:46 4046Hibernate抓取策略 默认fetch的配置,也就fet ... -
hibernate 全面学习【hibernate hsql语句学习 】
2008-07-04 15:31 4919Hibernate hql * 注意hql的大小写敏感性 ... -
hibernate 全面学习【hibernate 粗粒度分析 】
2008-07-04 15:16 1589Hibernate继承映射的第一 ... -
hibernate 全面学习【hibernate 集合映射】
2008-07-04 15:07 2650集合的映射 set list array map packag ... -
hibernate 全面学习【hibernate 复合主键映射】
2008-07-04 15:01 1838复合主键映射 通常将复合主键相关属性,单独抽取出来,建立一个 ... -
hibernate 全面学习 【hibernte 组件映射学习 】
2008-07-04 14:59 1151component(组件映射) 在hibernate中,c ... -
hibernate 全面学习 【hibernate 基本映射】
2008-07-04 14:16 1253Hibernate基本映射: 类-->数据库表 普通属 ... -
Hibernate createCriteria查询
2007-05-18 08:36 166311、创建一个Criteria实例 net.sf.hiberna ... -
hibernate中Query和Criteria的用法
2007-03-15 17:20 2974//Scenario 1: query all ... -
“generating artifacts"的解决!
2007-03-14 13:45 11653很多人在用myeclipse4.1.1对一个表生成映射文件的时 ... -
hibernate+spring学习例子
2007-02-26 15:00 1956看例子,来这习hibernate 和spring -
hibernate问题,贴上来
2007-02-26 11:06 2161(1)hibernate警告 Could no ... -
利用模板方式写一个管理hibernate 中session的方法
2007-02-23 09:41 3581package com.t48.hr.util; imp ... -
解快hibernate查询带中文乱码问题
2007-02-20 14:32 2432"from ManPo ma where ma.na ... -
Hibernate分页
2007-02-06 08:50 1535import org.hibernate.Query; imp ...
相关推荐
以上只是压缩包中部分可能包含的知识点,实际学习资料可能包括教程文档、示例代码、实战项目等,通过深入学习和实践,开发者可以全面掌握Hibernate的精髓,并将其应用到实际开发中,提高开发效率,降低维护成本。...
Hibernate缓存.docHibernate缓存.doc
**Hibernate缓存深入详解** 在Java企业级应用开发中,Hibernate作为一款强大的对象关系映射(ORM)框架,极大地简化了数据库操作。然而,随着应用规模的扩大,数据访问性能成为了一个不可忽视的问题。这时,...
Java Hibernate缓存深入详解
Hibernate缓存机制是提高应用程序性能的关键技术之一,它通过存储数据副本减少对物理数据库的访问。缓存可以分为两层:第一级缓存和第二级缓存。 **第一级缓存**是内置在Session中的,它是不可卸载的,也称为...
Hibernate 是一个流行的对象关系映射(ORM)框架,它提供了数据缓存机制以优化数据库访问性能。缓存机制分为一级缓存和二级缓存,两者都有助于减少对物理数据库的直接访问,从而提高应用程序的运行效率。 一级缓存...
本文将深入探讨Hibernate缓存的原理、类型及其对性能优化的影响。 ### Hibernate缓存原理 Hibernate缓存主要分为一级缓存和二级缓存。一级缓存,也称为会话缓存(Session Cache),是默认启用的,由Hibernate自动...
【Hibernate缓存深入详解】 在Java的持久化框架Hibernate中,缓存机制是提升系统性能的关键因素。它位于Hibernate应用和数据库之间,减少了对数据库的直接访问,从而提高了应用程序的运行速度。缓存中存储的是...
Hibernate二级缓存是一种提高应用程序性能的技术,它将数据存储在SessionFactory级别的缓存中,使得数据可以在不同的Session之间共享。这与一级缓存(Session级别)不同,一级缓存仅存在于单个Session生命周期内,当...
Hibernate 是一个流行的对象关系映射(ORM)框架,它允许Java...通过理解Hibernate缓存和事务管理,以及如何有效地执行查询,开发者可以创建高效、健壮的Java应用程序,降低与数据库交互的复杂性,同时提升系统性能。
Hibernate缓存原理及调优策略 Hibernate缓存原理调优策略
### Hibernate缓存机制及优化策略 #### 一、概述 Hibernate作为一款优秀的对象关系映射(ORM)框架,在Java开发领域被广泛应用于数据库操作。它提供了丰富的缓存机制来提高应用性能并降低数据库访问压力。本文将...
在Java的持久化框架Hibernate中,缓存机制是优化数据库操作性能的重要手段。本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存,通过具体的实例来阐述它们的工作原理和使用方法。 首先,我们从一级缓存开始...
**hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中,缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数,提高数据读取速度,并且在一定程度上降低了系统的负载。本文将...
在Hibernate中,一级缓存是每个Session内部的缓存,它自动管理实体的状态,当一个实体被加载到Session后,该实体的状态就会被缓存。然而,一级缓存的范围仅限于单个Session,当Session关闭后,其中的数据就会丢失。...
这篇博客文章“hibernate缓存ehcache用法”可能详细介绍了如何在Hibernate中配置和使用Ehcache。 首先,我们需要理解什么是缓存。缓存是一种存储技术,用于临时保存经常访问的数据,以减少对主存储器(如数据库)的...
**标题与描述解析** 标题"Hibernate 中文api 等学习资料"暗示了这是一组针对...通过阅读和学习这些资料,开发者可以全面掌握Hibernate框架,并将其应用于实际项目中,提升Java应用的数据访问层开发效率和质量。
总的来说,"hibernate二级缓存实例"是一个很好的学习资源,它可以帮助我们理解二级缓存的工作机制,掌握如何在项目中配置和使用,以及注意潜在的问题和优化策略。通过实践,我们可以更好地运用这一技术,提升Java...
Hibernate 二级缓存是针对SessionFactory级别的全局缓存,与一级缓存(Session级别)不同,一级缓存只在单个Session生命周期内有效。二级缓存则允许不同Session之间共享数据,提高了数据访问效率,减少了对数据库的...