zoukankan      html  css  js  c++  java

  • Hibernate 缓存

    1数据缓存:(date caching) 是一种将数据暂时存于内存缓存区中的技术,缓存通常是影响系统性能的关键因素 

    2.ORM的数据缓存策略有3种 
      1.事务级缓存:  分为 数据库事务和 应用级事务,是基于Session的生命周期的实现,每个session都会在内部维持一个数据缓存, 随session的创建和消亡. 

      2.应用级缓存:有多个事务共享,在SessionFactory层实现,由SessionFactory创建的session都共享次缓存 

      3.分布式应用缓存:有多个应用实例,由多个JVM共享的缓存模式,通过远程机制实现数据的同步.解决了多实例运行过程中数据的同步问题. 

    Hibernate 的缓存  只从下面两个方面发生作用 
    1.通过主键值加载对象 
    2.延迟加载 

    一级缓存 
    释义:是一个session缓存,就是一个Map,一个 id为key Object 为value 的Map,Hibernate对一级缓存使用自动维护,没有提供任何配置功能,但是可以通过session提供方法来进行一些手动的干预, 
    必须的 不能卸载的 

    1.evict(); 用于将对象从Session的一级缓存中清除 
    2.clear(); 将一级缓存中的对象全部清除. 

    从上面可以看出 session缓存中不可能存在两个id 相同的key 对应的object 
    所以 使用 session保存或者 udpate 的时候 需要使用 evict()清除指定的重复对象. 
      
    1.evict()的使用 

    Java代码  收藏代码
    1. public void testEvict(){  
    2.         Configuration config=new Configuration().configure();  
    3.         SessionFactory factory=config.buildSessionFactory();  
    4.         Session session=factory.openSession();  
    5.         Transaction tr=session.beginTransaction();  
    6.         //一级缓存: session缓存 中 通过 id 获取对象  
    7.         Integer deptId=new Integer(21);  
    8.         Dept deptOne=(Dept)session.get(Dept.class, deptId);  
    9.           
    10.         Dept deptTwo =new Dept();  
    11.         deptTwo.setDeptId(deptId);  
    12.         deptTwo.setDeptName("采购部");  
    13.         deptTwo.setCreateDate("2000-03-10");  
    14.           
    15.         session.evict(deptOne); //如果不先清除 相同id的 deptOne   下面的 saveOrUpdate 就会报错  
    16.         session.saveOrUpdate(deptTwo);  
    17.           
    18.         tr.commit();  
    19.     }  



    2.clear的使用 (如果执行批量修改的时候 需要使用大量的缓存这时就定时清空缓存) 

    Java代码  收藏代码
    1. public void testClear(){  
    2.         Configuration config=new Configuration().configure();  
    3.         SessionFactory factory=config.buildSessionFactory();  
    4.         Session session=factory.openSession();  
    5.         Transaction tr=session.beginTransaction();  
    6.         for(int i=0;i<10000;i++){  
    7.             Dept deptTwo=new Dept();  
    8.             deptTwo.setDeptName("才购物");  
    9.             deptTwo.setCreateDate("2002-01-02");  
    10.             session.save(deptTwo);  
    11.             if(i%20==0){  
    12.                 session.flush();  
    13.                 session.clear();  
    14.             }  
    15.         }  
    16.         tr.commit();  
    17.         session.close();  
    18.     }  



    二级缓存 
    释义:1实现原理 和一级缓存一样 同样是一个 Id 为key Object 为value的一个Map集合 
    2只是作用范围 扩大到 sessionFactory ,能够被所有的session共享 
    3.非必须 可选的 ,可插拔缓存插件,能够在每个类或者集合的粒度上配置. 

    功能分类: 
        内置缓存: 只读用于存放映射文件的数据及预定的sql语句, 
                  映射元数据是映射文件中数据的副本 
                  预定的sql语句:由Hibernate在初始化阶根据元数据推导生成. 
        外置缓存: 为配置插件,一般不启用. 

    二级缓存的工作过程: 
    1.执行各种查询时,如果获取的结果集为实体对象的集合,则将所有的实体对象根据id 存放 Map集合  即 二级缓存. 

    2.根据id 获取对象的时候,首先会在一级缓存中查找,如果无法找到,而此时这个类又配置了二级缓存,则将在二级缓存中继续查找,若仍然无法找到,则会从数据库中查找,然后将结果通过id放入缓存中, 

    3.删除 ,更新及 增加的时候  更新缓存 

    二级缓存的使用 
    1.作为一个可插入主键,一般在使用的时候进行配置,只有具备以下特征的对象才可以放入二级缓存中. 
      1 较少被修改的数据 
      2.非重要,能偶尔出现并发的数据 
      3.不会被并发访问的数据 
      4.参数数据 

    相对而言, 以下特征数据不适合放入二级缓存 
      1.常被修改 
      2.财务数据, 绝不容许出现并发 
      3.与其他应用共享 


    Hibernate 缓存在查询中的应用 

    1.session.load:先从 一级缓存中查找 ,如果配置了二级缓存 会在二级缓存中查找,然后在数据库中查找,然后会填充到 一级缓存 二级缓存中 

    2.session.get:不会在二级缓存中查找对象,会如果在一级缓存中找不到 会直接在数据库中查找 

    3.query.list: 会首先检查是否配置了查询缓存,如果配置了则在查询缓存中查找,如果找不到,则直接在数据中查询,,获取后会填充一级缓存,和二级缓存及 查询缓存. 数据发生任何变化时,查询缓存都会清空. 

    4.iterator:会首先通过查询语句获取id值的列表,然后使用session的load的方法获取需要对象的值. 

    Hibernate的检索策略 
    1.类级别检索   : 立即检索, 延迟检索 
    2.关联级别检索 : 立即检索, 延迟检索, 迫切左外连接检索 

    1.类级别 立即检索: 
    释义:指的是 在 配置文件中的class 中加入 lazy=false| true 的配置 .(默认为延迟检索:lazy=true,立即检索为 lazy=false);立即检索,只会影响 session.load 的方法 即 在加载的时候就会执行sql查询,而不是在使用对象属性的时候才执行sql查询 
    session.get  是不会有 sql语句的 

    Java代码  收藏代码
    1. //立即检索: 此时不会返回 代理对象 而是立刻执行 sql语句 查询对象  
    2.     public void testQueryLoad1(){  
    3.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    4.                 //执行上面这句 就会打印 sql语句  
    5.     }  



    2.类级别 延迟检索: 
    释义:在class 上配置 lazy=true (可以省略,默认延迟) .返回代理对象,即 只有id有值 ,其他的属性全是 null. 在hibernate运行时动态生成的扩展类,它继承了目标类,并且  在第一访问的时候才会初始化 这个代理对象 

    Java代码  收藏代码
    1. //延迟检索 会返回代理对象 不会立刻执行 sql语句 查询对象  
    2.     public void testQueryLoad1(){  
    3.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    4.           
    5.         System.out.println("部门名称:"+dept.getDeptName());  
    6.         //在执行上面这句时 才执行 sql语句 去查询,也就是第一次 (因为返回的代理对象,除id 外 其他的值都为空,所以才去查询)  
    7.     }  


    延迟检索下 出现的一些不同的情况 

    Java代码  收藏代码
    1.        //检索的对象不存在  
    2. public void testQueryLoad1(){  
    3.     Dept dept=(Dept)session.load(Dept.class,new Integer(-2));  
    4.                //执行上面不会报错  
    5.     System.out.println("部门名称:"+dept.getDeptName());  
    6.     //下面出现异常 ,因为 id为-2 的Dept不存在   
    7. }  
    8.       //session范围内 没有访问实体对象.(Hibernate会在第一访问代理对象的时候才会初始化代理对象)  
    9.      public void testQueryLoad1(){  
    10.     Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    11.     session.close();  
    12.                //执行上面不会报错  
    13.     System.out.println("部门名称:"+dept.getDeptName());  
    14.     //下面出现异常 ,session关闭了 代理对象没有初始化  
    15. }  
    16.   
    17.   
    18.       //延迟检索 会返回代理对象 不会立刻执行 sql语句 查询对象  
    19. public void testQueryLoad1(){  
    20.     Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    21.       
    22.     System.out.println("部门ID:"+dept.getDeptId());  
    23.     //此时 根本就没有执行sql语句 因为 代理类 中的id 的默认值就是 我们设置的2,此时还是不会触发hibernate初始化代理实例  
    24.               session.close();  
    25.               System.out.println("部门名称:"+dept.getDeptName());  
    26.                //报错,因为 代理没有被初始化过.  
    27.                  
    28. }  
    29.   
    30.      //显示的初始化代理对象  
    31.       public void testQueryLoad1(){  
    32.     Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    33.     //显示的初始化代理对象      
    34.     Hibernate.initialize(dept.getDeptName());  
    35.       
    36.     System.out.println("部门名称:"+dept.getDeptName());  
    37.       
    38. }  
    39.   
    40.        //显示初始化后  不会报错了.  
    41.       public void testQueryLoad1(){  
    42.     Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    43.     //显示的初始化代理对象      
    44.     Hibernate.initialize(dept.getDeptName());  
    45.     session.close();  
    46.     System.out.println("部门名称:"+dept.getDeptName());  
    47.       
    48. }  
    49.   
    50.        //隐式 的触发hibernate的初始化代理对象  
    51.        public void testQueryLoad1(){  
    52.     Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    53.      //隐式 的触发hibernate的初始化代理对象(就是在session范围 第一次访问代理对象,此时就会触发hibernate的初始化)   
    54.     System.out.println("部门名称:"+dept.getDeptName());  
    55.     session.close();  
    56.     System.out.println("部门名称:"+dept.getDeptName());  
    57.       
    58. }  
    59.        



    1.关联级别 立即检索: 
    释义:就是设置有关联的类是否立即检索(查询),在set 配置节点中 添加 lazy=false.就表示立即检索, true 就表示 延迟检索,怎么判断呢? 
    就从sql语句的打印中可以看出 
      立即检索: 在没有利用关联对象的时候,就执行了sql到数据库中将关联类给查询了一把.(是不是有点耗性能啊?) 
      延迟检索: 只有在你利用到关联对象的时候,才执行sql到数据库中 查询 

    Java代码  收藏代码
    1. //类级别关联 立即检索 Dept.hbm.xml: <set name="employees" lazy=false inverse=false> ...   
    2.     public void testQueryRaload1(){  
    3.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    4.         //这行这句话的时候  就 执行了两个sql 一个是 查询 Dept 一个是查询 Employee  (立即关联执行sql)  
    5.         System.out.println("部门名称:"+dept.getDeptName());  
    6.         System.out.println("开始检索关联的员工信息");  
    7.         System.out.println("部门员工数量"+dept.getEmployees().size());  
    8.     }  



    1.关联级别 延迟检索: 
    释义:默认就是 延迟检索 lazy=true 可以省略,只有在你利用到关联对象的时候,才执行sql到数据库中 查询 

    Java代码  收藏代码
    1. //类级别关联 延迟检索 Dept.hbm.xml: <set lazy=true inverse=false> ...   
    2.     public void testQueryRaload1(){  
    3.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    4.         //执行这句话的时候  就 只执行一个sql 查询 dept  
    5.         System.out.println("部门名称:"+dept.getDeptName());  
    6.         System.out.println("开始检索关联的员工信息");  
    7.         System.out.println("部门员工数量"+dept.getEmployees().size());  
    8.         //执行上面的那句话之前  才执行 sql 去查询 employee   
    9.     }  



    //既然是延迟 是不是 又会出现 和 类级别中的延迟检索出现的一些类似特殊情况呢? 答案:是肯定的 

    Java代码  收藏代码
    1. //类级别关联 延迟检索 Dept.hbm.xml: <set lazy=true inverse=false> ...   
    2.         //session 关闭后 关联对象没有被初始化   
    3.     public void testQueryRaload1(){  
    4.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    5.         //执行这句话的时候  就 只执行一个sql 查询 dept  
    6.         System.out.println("部门名称:"+dept.getDeptName());  
    7.         System.out.println("开始检索关联的员工信息");  
    8.         session.close(); //session 范围内没有访问对象  
    9.         System.out.println("部门员工数量"+dept.getEmployees().size());  
    10.                   
    11.         //报错了,关联对象没有被初始化  
    12.     }  
    13.   
    14. //这个不会报错  
    15. //类级别关联 延迟检索 Dept.hbm.xml: <set lazy=true inverse=false> ...   
    16.     //sesssion 关闭前 初始化关联对象  
    17.     public void testQueryRaload1(){  
    18.         Dept dept=(Dept)session.load(Dept.class,new Integer(2));  
    19.         //执行这句话的时候  就 只执行一个sql 查询 dept  
    20.         System.out.println("部门名称:"+dept.getDeptName());  
    21.         System.out.println("部门员工数量"+dept.getEmployees().size());  
    22.         System.out.println("开始检索关联的员工信息");  
    23.         session.close(); //session 范围内没有访问对象  
    24.         System.out.println("部门员工数量"+dept.getEmployees().size());  
    25.         //执行上面的那句话之前  才执行 sql 去查询 employee   
    26.     }  



    3.关联级别 迫切左外连接检索: 
    释义:将 set 节点的 out-join=true  就可以了,这个好像和 立即检索类似,只是将 原本的两个sql 变成 一个 left join 的查询   只查询了一次 只有一个sql语句 

    Java代码  收藏代码
      1. //类关联级别  迫切左外连接查询. <set out-join="true" invers="true"  
      2. public void testQueryOutJoin(){  
      3.     Dept dept =(Dept)session.load(Dept.class,new Integer(2));  
      4.     //执行上面代码时 ,就会执行一条  left join 的sql 查询数据库   
      5.     System.out.println("员工名称:"+dept.getDeptName());  
      6.       
      7. }  
  • 相关阅读:
    codechef BIBOARD
    Tree
    NOIWC2021总结
    星际穿越
    GDKOI总结
    lg4229
    P3320 [SDOI2015]寻宝游戏
    P6670 [清华集训2016] 汽水
    P6326 Shopping
    P3060 [USACO12NOV]Balanced Trees G
  • 原文地址：https://www.cnblogs.com/jifeng/p/2941189.html
Copyright © 2011-2022 走看看