hibernate12–缓存详解编程语言

<?xml version="1.0"?> 
<!DOCTYPE hibernate-mapping PUBLIC 
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
 
<hibernate-mapping package="cn.bdqn.bean"> 
  <class name="Emp"> 
  <!-- 配置2级缓存策略 --> 
    <cache usage="read-only"/> 
   
       <id name="empNo">  
          <generator class="assigned"/><!-- 手动给主键赋值 --> 
       </id>   
       <property name="empName"/> 
       <property name="job"/> 
       <property name="sal" column="salary"/> 
       <property name="hireDate"/> 
       <!-- 配置多对一关联 
       name:对应的是  本类中 关联关系的属性名 
       column:对应数据库中 两个表的  外键！ 
       class:关联的实体类 
       --> 
       <many-to-one  name="dept" column="DEPTNO" class="Dept"/>  
  </class> 
</hibernate-mapping>

<ehcache> 
 
<!-- java.io.tmpdir：临时系统文件！  可以换成自己创建的目录下 --> 
    <diskStore path="java.io.tmpdir"/> 
 
 
    <!-- 
  maxElementsInMemory:在内存中 最大的存储量  10000对象 
  eternal：是否永远不销毁 
  timeToIdleSeconds：当前缓存的数据闲置多少时间被销毁  以秒为单位 
  timeToLiveSeconds：当前缓存的数据超过多少时间被销毁 以秒为单位 
  overflowToDisk： 是否写入磁盘 
  diskPersistent:硬盘文件是否永久保存 
  memoryStoreEvictionPolicy：  缓存清理策略： 
 
         FIFO ，first in first out (先进先出). 
          
        LFU ， Less Frequently Used (最少使用). 
        意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。 
         
        LRU ，Least Recently Used(最近最少使用).  
        (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了， 
        而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。 
    --> 
    <defaultCache 
            maxElementsInMemory="10000" 
            eternal="false" 
            timeToIdleSeconds="120" 
            timeToLiveSeconds="120" 
            overflowToDisk="true" 
            memoryStoreEvictionPolicy="LRU" 
            /> 
</ehcache>

package cn.bdqn.test; 
 
import java.util.ArrayList; 
import java.util.List; 
 
import oracle.net.aso.s; 
 
import org.hibernate.CacheMode; 
import org.hibernate.Criteria; 
import org.hibernate.Query; 
import org.hibernate.Session; 
import org.hibernate.SessionFactory; 
import org.hibernate.Transaction; 
import org.hibernate.cfg.Configuration; 
import org.hibernate.criterion.DetachedCriteria; 
import org.hibernate.criterion.MatchMode; 
import org.hibernate.criterion.Order; 
import org.hibernate.criterion.Projections; 
import org.hibernate.criterion.Property; 
import org.hibernate.criterion.Restrictions; 
import org.hibernate.transform.Transformers; 
import org.junit.After; 
import org.junit.Before; 
import org.junit.Test; 
 
import com.sun.org.apache.xml.internal.security.encryption.Transforms; 
 
import cn.bdqn.bean.Dept; 
import cn.bdqn.bean.Emp; 
import cn.bdqn.util.HibernateUtil; 
 
public class EmpTest { 
     
    /** 
     * 1级缓存：  session中的缓存 
     *  clear():清空session中所有的缓存对象 
     *  evict():清除session中指定的对象 
     */ 
     
    @Test 
    public   void  test01(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp = (Emp) session.get(Emp.class, 1); // 产生1条sql 
        session.clear();  //清空缓存 
        emp = (Emp) session.get(Emp.class, 1);  //产生1条sql 
    } 
    @Test 
    public   void  test02(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp = (Emp) session.load(Emp.class, 1);  
        session.clear();  //清空缓存 
        emp = (Emp) session.load(Emp.class, 1);   
    } 
     
    @Test 
    public   void  test03(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp1 = (Emp) session.get(Emp.class, 1); //产生1条sql 
        Emp emp2 = (Emp) session.get(Emp.class, 2); //产生1条sql 
        session.evict(emp1);  //清除指定的 
    } 
     
    @Test 
    public   void  test04(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
           Emp emp=new Emp(); 
           emp.setEmpNo(51); 
           emp.setEmpName("haha"); 
           session.save(emp); 
           session.evict(emp);  //清除指定的 
           transaction.commit(); // 能保存到数据库中吗？ 肯定不能保存  除非把 session.evict(emp); 去掉 
    } 
 
     
    @Test 
    public   void  test05(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp=new Emp(); 
        emp.setEmpNo(52); 
        emp.setEmpName("haha"); 
        session.save(emp);  //持久态 
        System.out.println("********"); 
        session.flush();   //产生sql语句  把 emp对象 同步到 数据库 
        System.out.println("********"); 
        session.evict(emp);  //清除指定的   但是 已经  清理了 缓存 
        transaction.commit(); // 能保存到数据库中,因为已经flush 
    } 
     
     
    @Test 
    public   void  test06(){ 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp=(Emp) session.get(Emp.class, 1);  //持久化 
        emp.setEmpName("haha");   //emp 脏对象 
        System.out.println("flush前******************"); 
        session.flush();  //同步数据库 
        System.out.println("flush后******************"); 
        emp=(Emp) session.get(Emp.class, 1);  //持久化 
        System.out.println(emp.getEmpName());  //输出 haha   证明同步到数据库中了 
        emp.setEmpName("heihei");   //emp 脏对象 
        transaction.commit(); 
    }     
     
     
    /** 
     * 2级缓存：  进程或者是集群范围内的缓存！是sessionFactory的缓存！ 
     * 一个sessionFactory可以创建N个session！ 
     * 也就是说 在2级缓存中的数据，N个session共享！ 
     *  
     *  
     * 2级缓存适合存放的数据： 
     * 01.不经常被修改的数据 
     * 02.不敏感的数据  （财务数据不能放入） 
     * 03.共享的数据   
     *  
     *  
     * 配置ehCache缓存 
     * 01.引入jar 
     * 02.找到对应xml文件 
     * 03.在hibernate.cfg.xml文件中  开启和配置缓存 
     * 04.在对应的映射文件中  配置  缓存的策略 
     */ 
     
     
    @Test 
    public   void  test07(){  //之前是 两条sql语句 
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp = (Emp) session.get(Emp.class, 1); // 产生1条sql 
        session.clear();  //清空缓存 
        emp = (Emp) session.get(Emp.class, 1);  
    } 
     
    /** 
     * 验证我们  映射文件中的    <cache usage="read-only"/> 
     */ 
    @Test 
    public   void  test08(){   
        Session session = HibernateUtil.getCurrentSession(); 
        Transaction transaction = session.beginTransaction(); 
        Emp emp = (Emp) session.get(Emp.class, 1); // 产生1条sql 
        emp.setEmpName("hahaahaha"); 
        session.update(emp); 
        transaction.commit();  //报错   can't  writer  to readonly  object!! 
    } 
     
     
     
     
    //java.io.tmpdir：临时系统文件！  可以换成自己创建的目录下 
    @Test 
    public  void  test09(){ 
        System.out.println(System.getProperty("java.io.tmpdir")); 
    } 
     
     
    /** 
     * 设置2级缓存 模式 
     * CacheMode.IGNORE: 不与2级缓存关联                                产生2条sql 
     * CacheMode.NORMAL：与2级缓存关联,可读可写                   产生1条sql 
     * CacheMode.GET：与2级缓存关联,只读                                  产生1条sql 
     * CacheMode.PUT：与2级缓存关联,只写                                  产生2条sql 
     * CacheMode.REFRESH：与2级缓存关联,只写   
     * 通过 hibernate.cache.use_minimal_puts 的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。 
     *                     产生2条sql 
     */ 
    @Test 
    public  void  test10(){ 
     Session session = HibernateUtil.getCurrentSession(); 
     Transaction transaction = session.beginTransaction(); 
        Emp emp = (Emp) session.get(Emp.class, 1); // 产生1条sql 
        session.clear(); 
        //设置缓存模式 
        session.setCacheMode(CacheMode.REFRESH); 
        emp = (Emp) session.get(Emp.class, 1);  
         
         
    } 
     
     
     
    /* 
     * 查询缓存 
     *   基于2级缓存！   
     *   第一次在网页中查询一个关键字 为 java的所有 页面 可能需要等待 2S 
     *   第2次在网页中查询一个关键字 为 java的所有 页面   必须 小于2S 
     *    
     *   01.去核心配置文件中配置 
     *   <property name="cache.use_query_cache">true</property> 
     *   02.手动开启查询缓存 
     *   query.setCacheable(true); 
     */ 
     
     
    @Test 
    public void test11(){ 
        Session session = HibernateUtil.getCurrentSession(); 
         Query query = session.createQuery("from Dept"); 
         query.setCacheable(true); //首次开启 ！ 之后如果还是这个query语句，那么就会启动查询缓存 
         List list = query.list(); 
         for (Object object : list) { 
            System.out.println(object); 
        } 
         System.out.println("****************************"); 
         Query query2 = session.createQuery("from Dept"); 
         query2.setCacheable(true);  //先去 查询缓存中查找 
         List list2 = query2.list(); 
         for (Object object : list2) { 
            System.out.println(object); 
        } 
         System.out.println("****************************"); 
         Query query3 = session.createQuery("from Dept"); 
         //query3.setCacheable(true); 
         List list3 = query3.list(); 
         for (Object object : list3) { 
             System.out.println(object); 
         } 
         session.close(); 
          
    } 
 }