热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

(十一)Hibernate的检索策略

一、简介Session的缓存中可以存放相互关联的对象。当Hibernate从数据库中加载对象时,如果同时自动加载与之关联的所有对象,那么这些关联的对象就浪费了很多的内存空间。而我们

一、简介

Session的缓存中可以存放相互关联的对象。当Hibernate从数据库中加载对象时,如果同时自动加载与之关联的所有对象,那么这些关联的对象就浪费了很多的内存空间。而我们可以设置检索策略,来优化检索性能。

Hibernate提供了三种检索策略

        -立即检索策略:检索对象时立即加载对象以及关联的对象。 

        -延迟检索策略:使用时才会加载对象以及关联的对象。能避免多余加载不需要的对象。 

        -迫切左外连接检索策略 :利用SQL的外连接查询功能,能够减少select语句的数目。 

 技术分享图片 

二、类级别检索策略

定义:只加载某个类对象

类级别的检索策略包括立即检索和延迟检索。默认为延迟检索。

Hibernate中允许在映射文件中配置检索策略。
类级别检索策略,可以配置元素中的lazy属性。属性可选值:true(延迟检索) false(立即检索)。默认值为true。 

类级别检索策略会影响Session的load方法。 

例子:

    我们来做一个小例子,在load方法加断点
        public class Demo {
            private Session session;

            @Test
            public void test() {
                //读取配置文件
                Configuration cOnf=new Configuration().configure();

                //根据配置创建factory
                SessionFactory sessiOnfactory=conf.buildSessionFactory();
                session = sessionfactory.openSession(); 
                 Transaction ts=session.beginTransaction(); 

                 Customer c=session.load(Customer.class, 7);//此处加断点来观察效果
                 System.out.println(c.getName()); 

                ts.commit();
                session.close();
                sessionfactory.close();
            }

        }

        当lazy属性为true时,调用load方法什么都不输出,使用对象时才输出select语句。
        当lazy属性为false时,调用load方法会直接输出select语句。

 原理: 

当为延迟检索策略时,执行load方法时,是返回当前对象的代理对象,这个代理对象由Hibernate动态生成,

代理对象继承了当前对象,仅仅初始化了OID属性,其他属性都为null,当程序访问代理类属性时,

Hibernate才会初始化代理对象,初始化过程执行select语句,从数据库加载所有数据。

三、一对多关联级别的策略策略

关联级别检索策略:查询有关联关系的对象时,加载对象时是否需要将关联的对象加载。

在映射文件中,使用元素来配置一对多或者多对多的关联关系。

元素中有lazy和fetch属性决定加载策略。

lazy属性:和类级别加载策略一致。
         默认值为true。即使用延迟检索。 

         当lazy为false时,使用立即检索。 

         当lazy为extra时,采用加强延迟检索策略,它尽可能的延迟集合被初始化的时机。例如程序访问集合的一些属性时,如访问size()、contains()、isEmpty()这些方法时,如果指定了extra,就不会加载集合,仅通过特定的语句查询必要的信息。 

例子 :

            public class Demo {
                private Session session;

                @Test
                public void test() {
                    //读取配置文件
                    Configuration cOnf=new Configuration().configure();

                    //根据配置创建factory
                    SessionFactory sessiOnfactory=conf.buildSessionFactory();
                    session = sessionfactory.openSession(); 
                     Transaction ts=session.beginTransaction();  
                     //加载Customer对象
                     Customer c=(Customer)session.get(Customer.class, 7);
                     //加载Customer关联的Order对象
                     for(Order o:c.getOrders()){
                         System.out.println(o.getName());
                     }

                    ts.commit();
                    session.close();
                    sessionfactory.close();
                }

            }

    当我们lazy属性为false时,在执行get方法时,会使用立即检索策略,会执行两个select语句,加载Customer和关联的Orders集合。 

    当我们lazy属性为true时,执行get方法,只会执行一句select语句,此时Customer的Orders属性引用一个没有被初始化的集合代理类,此时Orders集合中不存在任何Order对象,当我们使用order时,才会初始化集合代理类,才会到数据库中检索所有关联的Order对象
fetch属性:决定加载集合时查询语句的格式。取值为:select 、subselect、join 

          select:(默认值)使用普通的select语句进行查询。 

          subselect:使用子查询加载集合数据。当查找多个对象时才有用,例如查找多个用户,每个用户有多个订单 

          join:采用迫切左外连接检索策略进行查询。fetch属性设为join,lazy属性将被忽略,在查询对象时一定会加载与之关联的对象。   

例子:

        public class Demo {

                    private Session session;

                    @Test
                    public void test() {
                        //读取配置文件
                        Configuration cOnf=new Configuration().configure();

                        //根据配置创建factory
                        SessionFactory sessiOnfactory=conf.buildSessionFactory();
                        session = sessionfactory.openSession(); 
                         Transaction ts=session.beginTransaction(); 

                        //加载Customer对象
                         Customer c=(Customer)session.get(Customer.class, 7);

                         //加载关联的Order对象
                         for(Order o:c.getOrders()){
                             System.out.println(o.getName());
                         }

                        ts.commit();
                        session.close();
                        sessionfactory.close();
                    }

                } 
            当fetch属性为默认值(select)时,打印的sql语句
                    Hibernate: 
                        select
                            customer0_.id as id1_0_0_,
                            customer0_.name as name2_0_0_ 
                        from
                            customer customer0_ 
                        where
                            customer0_.id=? 
                    Hibernate: 
                        select
                            orders0_.cid as cid3_1_0_,
                            orders0_.id as id1_1_0_,
                            orders0_.id as id1_1_1_,
                            orders0_.name as name2_1_1_,
                            orders0_.cid as cid3_1_1_ 
                        from
                            orders orders0_ 
                        where
                            orders0_.cid=?
            当fetch属性为join时,打印select语句,采用左外连接的查询语句,减少select语句
                    Hibernate: 
                        select
                            customer0_.id as id1_0_0_,
                            customer0_.name as name2_0_0_,
                            orders1_.cid as cid3_1_1_,
                            orders1_.id as id1_1_1_,
                            orders1_.id as id1_1_2_,
                            orders1_.name as name2_1_2_,
                            orders1_.cid as cid3_1_2_ 
                        from
                            customer customer0_ 
                        left outer join
                            orders orders1_ 
                                on customer0_.id=orders1_.cid 
                        where
                            customer0_.id=?
    演示fetch属性为subselect时,我们查询所有Customer,然后使用每一个Customer的Orders集合
            public class Demo {

                private Session session;
                @Test
                public void test() {
                    //读取配置文件
                    Configuration cOnf=new Configuration().configure();

                    //根据配置创建factory
                    SessionFactory sessiOnfactory=conf.buildSessionFactory();
                    session = sessionfactory.openSession(); 
                     Transaction ts=session.beginTransaction(); 

                     //查找所有Customer
                    List customerlist=session.createQuery("from Customer").list();  
                    //加载每个Customer关联的Orders集合
                    for(Customer c:customerlist){
                        System.out.println(c.getOrders().size());
                    }
                    ts.commit();
                    session.close();
                    sessionfactory.close();
                }

            }
            打印的语句,使用了子查询语句 
            当fetch属性为subselect时,Hibernate能够通过带有子查询的select语句,来整批量的初始化多个对象的集合中的实例。    


                Hibernate: 
                    select
                        customer0_.id as id1_0_,
                        customer0_.name as name2_0_ 
                    from
                        customer customer0_
                Hibernate: 
                    select
                        orders0_.cid as cid3_1_1_,
                        orders0_.id as id1_1_1_,
                        orders0_.id as id1_1_0_,
                        orders0_.name as name2_1_0_,
                        orders0_.cid as cid3_1_0_ 
                    from
                        orders orders0_ 
                    where
                        orders0_.cid in (
                            select
                                customer0_.id 
                            from
                                customer customer0_
                        )

fetch和lazy结合

技术分享图片

四、多对一关联级别的策略策略

元素一样,元素中也有lazy和fetch属性。

    lazy的可选值有false(立即检索),proxy(延迟检索),no-proxy(无代理延迟检索)
    fetch属性可选值为select 和 join  
        例子:设置订单配置文件中fetch属性为join
            public class Demo {

                private Session session;

                @Test
                public void test() {
                    //读取配置文件
                    Configuration cOnf=new Configuration().configure();

                    //根据配置创建factory
                    SessionFactory sessiOnfactory=conf.buildSessionFactory();
                    session = sessionfactory.openSession();  
                     Transaction ts=session.beginTransaction(); 
                    //加载订单对象
                     Order c=(Order)session.get(Order.class, 6);
                     //加载关联的Customer对象
                     System.out.println(c.getCustomer().getName());


                    ts.commit();
                    session.close();
                    sessionfactory.close();
                }

            }
        则在执行get方法时,会直接使用外连接查询。忽略lazy。
                    Hibernate: 
                        select
                            order0_.id as id1_1_0_,
                            order0_.name as name2_1_0_,
                            order0_.cid as cid3_1_0_,
                            customer1_.id as id1_0_1_,
                            customer1_.name as name2_0_1_ 
                        from
                            orders order0_ 
                        left outer join
                            customer customer1_ 
                                on order0_.cid=customer1_.id 
                        where
                            order0_.id=?

五、批量检索

  元素中包含batch-size属性。设定批量检索的数量。可选值为正整数,默认为1。 
仅用于关联级别的立即检索和批量检索

            我们在Customer配置文件中设置批量延迟检索
             

            public class Demo {

                private Session session;

                @Test
                public void test() {
                    //读取配置文件
                    Configuration cOnf=new Configuration().configure();

                    //根据配置创建factory
                    SessionFactory sessiOnfactory=conf.buildSessionFactory();
                    session = sessionfactory.openSession(); 
                     Transaction ts=session.beginTransaction(); 
                     //加载所有Customer对象
                    List customerlist=session.createQuery("from Customer").list();
                    for(Customer c:customerlist){
                        System.out.println(c.getOrders().size());
                    }
                    ts.commit();
                    session.close();
                    sessionfactory.close();
                }

            }
    我们使用延迟检索,当使用到每个Customer的orders时,才加载Orders,每执行一次循环,就打印一个select语句。 

    如果有很多Customer对象,那么就会打印很多的select语句。 

    所以我们可以使用批量检索。只需要将的batch-size属性设置为3.  

    所以会批量初始化三个Orders集合,使用in语句。这样当用到第一个第二个第三个对象的集合时,就不会再发送语句。

(十一)Hibernate的检索策略


推荐阅读
  • 本文详细介绍了使用 Python 进行 MySQL 和 Redis 数据库操作的实战技巧。首先,针对 MySQL 数据库,通过 `pymysql` 模块展示了如何连接和操作数据库,包括建立连接、执行查询和更新等常见操作。接着,文章深入探讨了 Redis 的基本命令和高级功能,如键值存储、列表操作和事务处理。此外,还提供了多个实际案例,帮助读者更好地理解和应用这些技术。 ... [详细]
  • Android中将独立SO库封装进JAR包并实现SO库的加载与调用
    在Android开发中,将独立的SO库封装进JAR包并实现其加载与调用是一个常见的需求。本文详细介绍了如何将SO库嵌入到JAR包中,并确保在外部应用调用该JAR包时能够正确加载和使用这些SO库。通过这种方式,开发者可以更方便地管理和分发包含原生代码的库文件,提高开发效率和代码复用性。文章还探讨了常见的问题及其解决方案,帮助开发者避免在实际应用中遇到的坑。 ... [详细]
  • 在探讨Hibernate框架的高级特性时,缓存机制和懒加载策略是提升数据操作效率的关键要素。缓存策略能够显著减少数据库访问次数,从而提高应用性能,特别是在处理频繁访问的数据时。Hibernate提供了多层次的缓存支持,包括一级缓存和二级缓存,以满足不同场景下的需求。懒加载策略则通过按需加载关联对象,进一步优化了资源利用和响应时间。本文将深入分析这些机制的实现原理及其最佳实践。 ... [详细]
  • 单链表的高效遍历及性能优化策略
    本文探讨了单链表的高效遍历方法及其性能优化策略。在单链表的数据结构中,插入操作的时间复杂度为O(n),而遍历操作的时间复杂度为O(n^2)。通过在 `LinkList.h` 和 `main.cpp` 文件中对单链表进行封装,我们实现了创建和销毁功能的优化,提高了单链表的使用效率。此外,文章还介绍了几种常见的优化技术,如缓存节点指针和批量处理,以进一步提升遍历性能。 ... [详细]
  • Squaretest:自动生成功能测试代码的高效插件
    本文将介绍一款名为Squaretest的高效插件,该工具能够自动生成功能测试代码。使用这款插件的主要原因是公司近期加强了代码质量的管控,对各项目进行了严格的单元测试评估。Squaretest不仅提高了测试代码的生成效率,还显著提升了代码的质量和可靠性。 ... [详细]
  • 作为软件工程专业的学生,我深知课堂上教师讲解速度之快,很多时候需要课后自行消化和巩固。因此,撰写这篇Java Web开发入门教程,旨在帮助初学者更好地理解和掌握基础知识。通过详细记录学习过程,希望能为更多像我一样在基础方面还有待提升的学员提供有益的参考。 ... [详细]
  • ButterKnife 是一款用于 Android 开发的注解库,主要用于简化视图和事件绑定。本文详细介绍了 ButterKnife 的基础用法,包括如何通过注解实现字段和方法的绑定,以及在实际项目中的应用示例。此外,文章还提到了截至 2016 年 4 月 29 日,ButterKnife 的最新版本为 8.0.1,为开发者提供了最新的功能和性能优化。 ... [详细]
  • Vue应用预渲染技术详解与实践 ... [详细]
  • 在 CentOS 6.5 系统上部署 VNC 服务器的详细步骤与配置指南
    在 CentOS 6.5 系统上部署 VNC 服务器时,首先需要确认 VNC 服务是否已安装。通常情况下,VNC 服务默认未安装。可以通过运行特定的查询命令来检查其安装状态。如果查询结果为空,则表明 VNC 服务尚未安装,需进行手动安装。此外,建议在安装前确保系统的软件包管理器已更新至最新版本,以避免兼容性问题。 ... [详细]
  • Java环境中Selenium Chrome驱动在大规模Web应用扩展时的性能限制分析 ... [详细]
  • 如何高效地安装并配置 PostgreSQL 数据库系统?本文将详细介绍从下载到安装、配置环境变量、初始化数据库、以及优化性能的全过程,帮助读者快速掌握 PostgreSQL 的核心操作与最佳实践。文章还涵盖了常见问题的解决方案,确保用户在部署过程中能够顺利解决遇到的各种挑战。 ... [详细]
  • 在使用SSH框架进行项目开发时,经常会遇到一些常见的问题。例如,在Spring配置文件中配置AOP事务声明后,进行单元测试时可能会出现“No Hibernate Session bound to thread”的错误。本文将详细探讨这一问题的原因,并提供有效的解决方案,帮助开发者顺利解决此类问题。 ... [详细]
  • 本文总结了JavaScript的核心知识点和实用技巧,涵盖了变量声明、DOM操作、事件处理等重要方面。例如,通过`event.srcElement`获取触发事件的元素,并使用`alert`显示其HTML结构;利用`innerText`和`innerHTML`属性分别设置和获取文本内容及HTML内容。此外,还介绍了如何在表单中动态生成和操作``元素,以便更好地处理用户输入。这些技巧对于提升前端开发效率和代码质量具有重要意义。 ... [详细]
  • 并发编程入门:初探多任务处理技术
    并发编程入门:探索多任务处理技术并发编程是指在单个处理器上高效地管理多个任务的执行过程。其核心在于通过合理分配和协调任务,提高系统的整体性能。主要应用场景包括:1) 将复杂任务分解为多个子任务,并分配给不同的线程,实现并行处理;2) 通过同步机制确保线程间协调一致,避免资源竞争和数据不一致问题。此外,理解并发编程还涉及锁机制、线程池和异步编程等关键技术。 ... [详细]
  • JavaScript XML操作实用工具类:XmlUtilsJS技巧与应用 ... [详细]
author-avatar
曾的曾的力
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有