• hibernate13--缓存


    <!DOCTYPE hibernate-configuration PUBLIC 
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
    <session-factory>
        <property name="connection.url">
            jdbc:oracle:thin:@localhost:1521:orcl
        </property>
        <property name="connection.username">t10</property>
        <property name="connection.password">t10</property>
        <property name="connection.driver_class">
            oracle.jdbc.OracleDriver
        </property>
        <!--方言  -->
        <property name="dialect">
            org.hibernate.dialect.Oracle9Dialect
        </property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <!-- 在我们的项目中使用currentSession-->
        <property name="current_session_context_class">thread</property>
        <!-- 开启配置2级缓存 -->
        <property name="cache.use_second_level_cache">true</property>
        <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
         <!-- 开启查询缓存 -->
        <property name="cache.use_query_cache">true</property>
    
    
        <!--加载我们配置的映射文件  全路径 -->
        <mapping resource="cn/bdqn/bean/Dept.hbm.xml" />
        <mapping resource="cn/bdqn/bean/Emp.hbm.xml" />
    
    </session-factory>
    </hibernate-configuration>
    <?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();
             
        }
        
        
        
        
        
        
    }
  • 相关阅读:
    传Windows 9预览版今秋发布
    谷歌上市十周年 成长为全球第二大技术公司
    Twitter CEO:有望进军中国 不会改变原则
    免费获得NOD32 半年、1年 激活码-14.08.12到期
    卡巴斯基正式版2015 简体中文版已经发布
    Google 宣布支持中文邮箱地址
    图片:走进柯达电影胶片厂
    Microsoft Visual Studio Ultimate 2013 with Update 3 CN+EN
    DataFrame衍生新特征操作
    isolation forest进行异常点检测
  • 原文地址:https://www.cnblogs.com/xtdxs/p/7093597.html
Copyright © 2020-2023  润新知