Hibernate的一级缓存

iteye_6287

于 2008-11-19 12:43:50 发布

阅读量91

点赞数

分类专栏： hibernate 文章标签： Hibernate SQL 单元测试 JDBC J#

hibernate 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Hibernate一级缓存：
(1) 一级缓存很短和session的生命周期一致，一级缓存又叫session级缓存或者
事务级缓存

(2) 支持一级缓存的方法：
get();
load();
iterator();只缓存实体对象
(3) 如何管理一级缓存
session.clear() session.evict(); session.flush();
(4) 如何避免大量数据入库导致内存溢出
先sessionflush()
在clear（）
(5) 如果数据量特别大可以可以考虑JDBC实现如果Jdbc也不能满足要求可以考虑采用数据库提供的特定数据导入工具

下面的实例中我们会一一验证以上的各条：

有这样的2个类


public class Clazz {
   private Integer id;
   private String name;
   private Set<Student> students=new HashSet<Student>();
}
public class Student {
   private Integer id;
   private String name;
   private Clazz clazz;
}

他们的映射文件分别是：


   <class name="com.june.hibernate.Student" table="t_student">
	   <id name="id">
	       <generator class="native"></generator>
	   </id>
	   <property name="name"></property>	
            <many-to-one name="clazz" cascade="save-update"></many-to-one> 	
   </class>

<class name="com.june.hibernate.Clazz" table="t_clazz">
	   <id name="id">
	       <generator class="native"></generator>
	   </id>
	   <property name="name"></property>	
	   <set name="students" inverse="true">
	      <key column="clazz"/>
	      <one-to-many class="com.june.hibernate.Student"/>
	   </set> 
</class>

请运行以下的所有的测试方法：


 package com.june.hibernate;

import java.io.Serializable;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class CacheLevel1Test extends TestCase{
	/**
	 * 在同一个session中2次执行load()查询
	 */
    public void testLoad(){
    	 Session session=null;
  	     Transaction tx=null;
  	   try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  		   Student student1=(Student)session.load(Student.class,1);
  		   System.out.println("student1.name="+student1.getName());
  		   System.out.println("stuent1.clazz.name"+student1.getClazz().getName());
  		   //不会发出sql语句，因为load使用缓存
  		   Student student2=(Student)session.load(Student.class,1);
  		   System.out.println("student1.name="+student1.getName());
  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }
    }
	/**
	 * 在同一个session中2次执行get()查询
	 */
    public void testGet(){
    	 Session session=null;
  	     Transaction tx=null;
  	   try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  		   Student student1=(Student)session.get(Student.class,1);
  		   System.out.println("student1.name="+student1.getName());
  		   System.out.println("stuent1.clazz.name"+student1.getClazz().getName());
  		   //不会发出sql语句，因为get使用缓存
  		   Student student2=(Student)session.get(Student.class,1);
  		   System.out.println("student1.name="+student1.getName());
  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }
    }
    /**
     * 查询实体
     */
    public void testIteratorEntity(){
   	 Session session=null;
 	     Transaction tx=null;
 	   try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 
 		   Student student1=(Student)session.createQuery("from Student s where s.clazz.id=1").iterate().next();
 		   System.out.println("student1.name="+student1.getName());
 		/**  Hibernate: select student0_.id as col_0_0_ from t_student student0_ where student0_.clazz=1
 		     Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.clazz as clazz1_0_ from t_student student0_ where student0_.id=?
 		     student1.name=Student_**0Of_Clazz000
 		     Hibernate: select student0_.id as col_0_0_ from t_student student0_ where student0_.clazz=1
 		     student2.name=Student_**0Of_Clazz000
        */
 		   //缓存中已经存在id=1的student 所以第二次查询 只是发出查询id 的sql 不会发出查询实体的sql
 		   //因为Iterator使用缓存
 		   Student student2=(Student)session.createQuery("from Student s where s.clazz.id=1").iterate().next();
 		   System.out.println("student2.name="+student2.getName());
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }
   }
    /**
     * 查询普通属性
     */
    public void testIteratorProperty(){
   	 Session session=null;
 	     Transaction tx=null;
 	   try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 
 		   String sname=(String)session.createQuery("select s.name from Student s where s.clazz.id=1").iterate().next();
 		   System.out.println("student1.name="+sname);
 		   //iterator查询普通属性，一级缓存不会缓存，所以不会发出sql语句
 		   String sname2=(String)session.createQuery("select s.name from Student s where s.clazz.id=1").iterate().next();
 		   System.out.println("student1.name="+sname2);
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }
   }
    /**
     * 在2个session中使用load
     */
    public void testTwoSessionLoad(){
    	 Session session=null;
  	     Transaction tx=null;
  	   try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  		   Student student1=(Student)session.load(Student.class,1);
  		   System.out.println("student1.name="+student1.getName());
  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }

	   try{
		   session=HibernateUtil.getSession();
		   tx=session.beginTransaction(); 
		   //会发出sql语句 session间不会共享一级缓存
		   //他会伴随这session生命周期的存在和消亡
		   Student student1=(Student)session.load(Student.class,1);
		   System.out.println("student1.name="+student1.getName());
		   tx.commit();
	   }catch(Exception e){
		   e.printStackTrace();
		   tx.rollback();
	   }finally{
		   HibernateUtil.colseSession(session);
	   }
    }
    /**
     * 在同一个session中load()查询save()过的数据
     */
    public void testLoadSaved(){
    	 Session session=null;
  	     Transaction tx=null;
  	   try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  		   Student student=new Student();
  		   student.setName("mary");
  		   Serializable id=session.save(student);

  		   //不会发出sql,因为save使用缓存
  		   Student student1=(Student)session.load(Student.class,id);
  		   System.out.println(student1.getName());

  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }
    }
    /**
     * 在同一个session 先调用load查询 然后执行session.clear()或执行session.evict();
     * 在调用load查询
     * clear()清理缓存,驱除全部
     * evict(Object object)从缓存中驱逐指定的对象
     */
    public void testLoadEvictLoad(){
   	 Session session=null;
 	     Transaction tx=null;
 	   try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 
 		   Student student1=(Student)session.load(Student.class,1);
 		   //发出sql语句
 		   System.out.println("student1.name="+student1.getName());
 		   //一级缓存无法取消但是可以管理，如session.clear() session.evict()
 		   //清理缓存
 		   session.clear();
 		   //session.evict(student1); //从缓存中逐出id=1的student

 		   Student student2=(Student)session.load(Student.class,1);
 		   //会发出sql语句 
 		   System.out.println("student1.name="+student1.getName());
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }
   }
    /**
     * 向数据库中添加10000条数据
     */
    public void testCache7(){
   	 Session session=null;
 	     Transaction tx=null;
 	      long  beginTime=System.currentTimeMillis();
 	   try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 		
 		   for(int i=0;i<1000;i++){
 			   Student student=new Student();
 			   student.setName("student_"+i);
 			   session.save(student);
 			   //每插入20条数据 就强制数据持久化
 			   //同时清楚缓存，避免大量数据造成内存溢出
 			   if(i % 20==0){
 				   session.flush();
 				   session.clear();
 			   }
 		   }		   
 		   System.out.println();
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }
 	   long endTime=System.currentTimeMillis();
 	   System.out.println(endTime-beginTime);
   }
}

下面这是初始化数据类：
在运行单元测试之前先要建立数据库并且运行下面这个类
初始化数据


ublic class InitialData {
   public static void main(String args[]){
	   Session session=null;
	     Transaction tx=null;
	   try{
		   session=HibernateUtil.getSession();
		   tx=session.beginTransaction(); 
		   for(int j=0;j<6;j++){
			   Clazz clazz=new Clazz();
			   clazz.setName("Clazz00"+j);
			   session.save(clazz);
			   for(int i=0;i<10;i++){
			   Student student=new Student();
			   student.setName("Student_**"+i+"Of_Clazz00"+j);
			   student.setClazz(clazz);
			   session.save(student);
			   }
		   }			 
		   for(int k=0;k<5;k++){
			   Clazz clazz=new Clazz();
			   clazz.setName("Empty_Clazz00"+k);
			   session.save(clazz);	 
		   }
		   for(int m=0;m<5;m++){
			   Student student=new Student();
			   student.setName("no_class_student00"+m);
			   session.save(student); 
		   }
		   tx.commit();
	      }catch(Exception e){
		   e.printStackTrace();
		   tx.rollback();
	   }finally{
		   HibernateUtil.colseSession(session);
	   }
  }
}