`
penghao122
  • 浏览: 363908 次
  • 性别: Icon_minigender_1
  • 来自: 广东珠海
社区版块
存档分类
最新评论

hibernate 全面学习 【hibernate 缓存学习 】

阅读更多
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);

一级缓存

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);
//		}
		
	}
}
分享到:
评论
1 楼 直直走 2009-08-12  
是啊  上一篇里,明显看出来bjsxt,北京尚学堂,不知道楼主是亲传弟子,还是看着下载视频的

相关推荐

    深入理解Hibernate缓存

    ### 深入理解Hibernate缓存 #### 一、Hibernate缓存概述 Hibernate作为一款流行的Java持久层框架,为开发者提供了高效且灵活的数据访问能力。其中,缓存机制是Hibernate性能优化的重要组成部分之一。理解Hibernate...

    hibernate学习资料大全

    以上只是压缩包中部分可能包含的知识点,实际学习资料可能包括教程文档、示例代码、实战项目等,通过深入学习和实践,开发者可以全面掌握Hibernate的精髓,并将其应用到实际开发中,提高开发效率,降低维护成本。...

    Hibernate缓存.doc

    Hibernate缓存.docHibernate缓存.doc

    Hibernate缓存深入详解 from ITEye

    **Hibernate缓存深入详解** 在Java企业级应用开发中,Hibernate作为一款强大的对象关系映射(ORM)框架,极大地简化了数据库操作。然而,随着应用规模的扩大,数据访问性能成为了一个不可忽视的问题。这时,...

    Java Hibernate缓存深入详解

    Java Hibernate缓存深入详解

    hibernate缓存机制

    Hibernate缓存机制是提高应用程序性能的关键技术之一,它通过存储数据副本减少对物理数据库的访问。缓存可以分为两层:第一级缓存和第二级缓存。 **第一级缓存**是内置在Session中的,它是不可卸载的,也称为...

    hibernate一级缓存和二级缓存的区别与联系

    Hibernate 是一个流行的对象关系映射(ORM)框架,它提供了数据缓存机制以优化数据库访问性能。缓存机制分为一级缓存和二级缓存,两者都有助于减少对物理数据库的直接访问,从而提高应用程序的运行效率。 一级缓存...

    Hibernate缓存,性能优化

    本文将深入探讨Hibernate缓存的原理、类型及其对性能优化的影响。 ### Hibernate缓存原理 Hibernate缓存主要分为一级缓存和二级缓存。一级缓存,也称为会话缓存(Session Cache),是默认启用的,由Hibernate自动...

    Hibernate缓存深入详解

    【Hibernate缓存深入详解】 在Java的持久化框架Hibernate中,缓存机制是提升系统性能的关键因素。它位于Hibernate应用和数据库之间,减少了对数据库的直接访问,从而提高了应用程序的运行速度。缓存中存储的是...

    Hibernate二级缓存

    Hibernate二级缓存是一种提高应用程序性能的技术,它将数据存储在SessionFactory级别的缓存中,使得数据可以在不同的Session之间共享。这与一级缓存(Session级别)不同,一级缓存仅存在于单个Session生命周期内,当...

    hibernate缓存和事务

    Hibernate 是一个流行的对象关系映射(ORM)框架,它允许Java...通过理解Hibernate缓存和事务管理,以及如何有效地执行查询,开发者可以创建高效、健壮的Java应用程序,降低与数据库交互的复杂性,同时提升系统性能。

    Hibernate缓存策略

    Hibernate缓存原理及调优策略 Hibernate缓存原理调优策略

    hibernate缓存

    ### Hibernate缓存机制及优化策略 #### 一、概述 Hibernate作为一款优秀的对象关系映射(ORM)框架,在Java开发领域被广泛应用于数据库操作。它提供了丰富的缓存机制来提高应用性能并降低数据库访问压力。本文将...

    Hibernate一级缓存、二级缓存以及查询缓存实例

    在Java的持久化框架Hibernate中,缓存机制是优化数据库操作性能的重要手段。本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存,通过具体的实例来阐述它们的工作原理和使用方法。 首先,我们从一级缓存开始...

    hibernate一级缓存、二级缓存和查询缓存

    **hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中,缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数,提高数据读取速度,并且在一定程度上降低了系统的负载。本文将...

    Spring集成的Hibernate配置二级缓存

    在Hibernate中,一级缓存是每个Session内部的缓存,它自动管理实体的状态,当一个实体被加载到Session后,该实体的状态就会被缓存。然而,一级缓存的范围仅限于单个Session,当Session关闭后,其中的数据就会丢失。...

    hibernate缓存ehcache用法

    这篇博客文章“hibernate缓存ehcache用法”可能详细介绍了如何在Hibernate中配置和使用Ehcache。 首先,我们需要理解什么是缓存。缓存是一种存储技术,用于临时保存经常访问的数据,以减少对主存储器(如数据库)的...

    Hibernate 中文api 等学习资料

    **标题与描述解析** 标题"Hibernate 中文api 等学习资料"暗示了这是一组针对...通过阅读和学习这些资料,开发者可以全面掌握Hibernate框架,并将其应用于实际项目中,提升Java应用的数据访问层开发效率和质量。

    hibernate二级缓存实例

    总的来说,"hibernate二级缓存实例"是一个很好的学习资源,它可以帮助我们理解二级缓存的工作机制,掌握如何在项目中配置和使用,以及注意潜在的问题和优化策略。通过实践,我们可以更好地运用这一技术,提升Java...

    hibernate 二级缓存详解

    Hibernate 二级缓存是针对SessionFactory级别的全局缓存,与一级缓存(Session级别)不同,一级缓存只在单个Session生命周期内有效。二级缓存则允许不同Session之间共享数据,提高了数据访问效率,减少了对数据库的...

Global site tag (gtag.js) - Google Analytics