Hibernate的一级缓存

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

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

有这样的2个类

Java代码

1. public class Clazz {   
2.    private Integer id;   
3.    private String name;   
4.    private Set<Student> students=new HashSet<Student>();   
5. }   
6. public class Student {   
7.    private Integer id;   
8.    private String name;   
9.    private Clazz clazz;   
10. }  

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;
}

 

他们的映射文件分别是：

Xml代码

1.    <class name="com.june.hibernate.Student" table="t_student">  
2.        <id name="id">  
3.            <generator class="native"></generator>  
4.        </id>  
5.        <property name="name"></property>       
6.             <many-to-one name="clazz" cascade="save-update"></many-to-one>     
7.    </class>  
8.   
9. <class name="com.june.hibernate.Clazz" table="t_clazz">  
10.        <id name="id">  
11.            <generator class="native"></generator>  
12.        </id>  
13.        <property name="name"></property>       
14.        <set name="students" inverse="true">  
15.           <key column="clazz"/>  
16.           <one-to-many class="com.june.hibernate.Student"/>  
17.        </set>    
18. </class>  
19.    

   <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>
 

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

 

 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);
   }
}