hibernate的二级缓存

public  class Student { 
   private Integer id; 
   private String name; 
   //一系列的setter.getter方法 
}

   < class  name ="com.sxt.hibernate.cache.entity.Student"  table ="sxt_hibernate_student" > 
         
    <!--  指定本类的对象使用二级缓存(这也可以放在hibernate.cfg.xml中统一指定) --> 
    <!--  
    <cache usage="read-only"/> 
     --> 
     < id  name ="id"  length ="4" > 
       < generator  class ="native" > </ generator > 
     </ id > 
     < property  name ="name"  length ="10" > </ property > 
   </ class >

< ehcache > 
  <!--  当二级缓存溢出时,对象保存的临时磁盘路径 --> 
         < diskStore  path ="java.io.tmpdir" /> 

        <!-- name="sampleCache2" 缓存名字 
                maxElementsInMemory="1000" 缓存里可存放的最大对象数. 
                eternal="true" 缓存对象是否永久有效(true表示是). 
                timeToIdleSeconds="120" 对象在缓存中存活的空闲时间,即空闲多久它就失效,单位是秒. 
                timeToLiveSeconds="120" 对象在缓存中存活的时间,单位是秒. 
                overflowToDisk="true"    当缓存溢出时,对象是否保存到磁盘上.保存的磁盘路径由<diskStore>中的path指定. 
        --> 
         < defaultCache 
                 maxElementsInMemory ="10000" 
                 eternal ="false" 
                 timeToIdleSeconds ="120" 
                 timeToLiveSeconds ="120" 
                 overflowToDisk ="true" 
                 /> 
</ ehcache >

< hibernate-configuration > 
   < session-factory > 
     < property  name ="hibernate.connection.url" >jdbc:oracle:thin:@localhost:1521:ORCL10 </ property > 
     < property  name ="hibernate.connection.driver_class" >oracle.jdbc.driver.OracleDriver </ property > 
     < property  name ="hibernate.connection.username" >scott </ property > 
     < property  name ="hibernate.connection.password" >yf123 </ property > 
     < property  name ="hibernate.dialect" >org.hibernate.dialect.Oracle9Dialect </ property > 
     < property  name ="hibernate.show_sql" >true </ property > 
     
    <!--  开启二级缓存,其实hibernate默认就是开启的,这里显示的指定一下 --> 
     < property  name ="hibernate.cache.use_second_level_cache" >true </ property > 
    <!--  指定二级缓存产品的提供商 --> 
     < property  name ="hibernate.cache.provider_class" >org.hibernate.cache.EhCacheProvider </ property > 
     
     < mapping  resource ="com/sxt/hibernate/cache/entity/Student.hbm.xml" /> 
     
    <!--  指定那些类使用二级缓存 --> 
     < class-cache  usage ="read-only"  class ="com.sxt.hibernate.cache.entity.Student" /> 
   </ session-factory > 
</ hibernate-configuration >

   public  static  void main(String[] args) { 
    Session session =  null; 
    Transaction t =  null; 

     /** 
     * 开启两个session中发出load查询 
     */ 
/*    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      Student student = (Student) session.load(Student.class, 1); 
      System.out.println("student.name=" + student.getName()); 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      // 不会发出查询语句，因为开启了二级缓存,session共享二级缓存 
      Student student = (Student) session.load(Student.class, 1); 
      System.out.println("student.name=" + student.getName()); 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    }*/ 
     
     /** 
     * 开启两个session中发出get查询 
     */ 
     try { 
      session = HibernateUtils.getSession(); 
      System.out.println(session); 
      t = session.beginTransaction(); 
      Student student = (Student) session.get(Student. class, 1); 
      session.clear(); 
      System.out.println( "student.name=" + student.getName()); 
      t.commit(); 
    }  catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    }  finally { 
      HibernateUtils.closeSession(session); 
    } 

     try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
       // 不会发出查询语句，因为开启了二级缓存,get使用二级缓存 
      Student student = (Student) session.get(Student. class, 1); 
      System.out.println( "student.name=" + student.getName()); 
      t.commit(); 
    }  catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    }  finally { 
      HibernateUtils.closeSession(session); 
    } 
  } 
}

   public  static  void main(String[] args) { 
    Session session =  null; 
    Transaction t =  null; 

     /** 
     * 开启两个session中发出load查询,使用SessionFactory清除二级缓存 
     */ 
/*    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      //load时,会把对象放到两个缓存中 
      Student student = (Student) session.load(Student.class, 1); 
      System.out.println("student.name=" + student.getName()); 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    } 
    //用SessionFacotry管理二级缓存 
    SessionFactory factory=HibernateUtils.getSessionFactory(); 
    //evict()把id为1的Student对象从二级缓存中清除. 
    factory.evict(Student.class, 1); 
    try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
      // 不会发出查询语句，因为开启了二级缓存,load也使用二级缓存 
      Student student = (Student) session.load(Student.class, 1); 
      System.out.println("student.name=" + student.getName()); 
      t.commit(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    } finally { 
      HibernateUtils.closeSession(session); 
    }*/ 


     /** 
     * 开启两个session中发出load查询,session对二级缓存的使用. 
     */ 
     try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
       //设置一级缓存和二级缓存的交互模式: 
       //GET表示在load时只是从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。 
       //PUT表示只往二级缓存中放数据,而不从中取数据. 
       //NORMAL表示从二级缓存中读、写数据。 
       //REFRESH表示仅向二级缓存写数据，但不从二级缓存中读数据。 
      session.setCacheMode(CacheMode.GET); 
      Student student = (Student) session.load(Student. class, 1); 
      System.out.println( "student.name=" + student.getName()); 
      t.commit(); 
    }  catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    }  finally { 
      HibernateUtils.closeSession(session); 
    } 
     try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
       // 会发出查询语句，因为前面设置了一级缓存和二级缓存的交互模式为GET,没有往二级缓存中放数据. 
      Student student = (Student) session.load(Student. class, 1); 
      System.out.println( "student.name=" + student.getName()); 
      t.commit(); 
    }  catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    }  finally { 
      HibernateUtils.closeSession(session); 
    } 
     
     try { 
      session = HibernateUtils.getSession(); 
      t = session.beginTransaction(); 
       //设置交互模式为PUT. 
      session.setCacheMode(CacheMode.PUT); 
       // 会发出查询语句，因为设置了一级缓存和二级缓存的交互模式为PUT,只是往二级缓存中放数据,并不去中取数据. 
      Student student = (Student) session.load(Student. class, 1); 
      System.out.println( "student.name=" + student.getName()); 
      t.commit(); 
    }  catch (Exception e) { 
      e.printStackTrace(); 
      t.rollback(); 
    }  finally { 
      HibernateUtils.closeSession(session); 
    } 
  } 
}