博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
(十一)Hibernate的检索策略
阅读量:5876 次
发布时间:2019-06-19

本文共 10510 字,大约阅读时间需要 35 分钟。

一、简介

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语句,从数据库加载所有数据。

 

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

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

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

< set >元素中有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=?

  

五、批量检索

  < class >和< set >元素中包含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语句。这样当用到第一个第二个第三个对象的集合时,就不会再发送语句。

  

 

 

  

 

转载于:https://www.cnblogs.com/yuexiaoyun/p/9452542.html

你可能感兴趣的文章
Android TabActivity使用方法
查看>>
Eclipse的 window-->preferences里面没有Android选项
查看>>
《麦田里的守望者》--[美]杰罗姆·大卫·塞林格
查看>>
遇到的那些坑
查看>>
央行下属的上海资信网络金融征信系统(NFCS)签约机构数量突破800家
查看>>
[转] Lazy evaluation
查看>>
常用查找算法总结
查看>>
被神话的大数据——从大数据(big data)到深度数据(deep data)思维转变
查看>>
修改校准申请遇到的问题
查看>>
Linux 进程中 Stop, Park, Freeze【转】
查看>>
文件缓存
查看>>
远程协助
查看>>
Scrum实施日记 - 一切从零开始
查看>>
关于存储过程实例
查看>>
配置错误定义了重复的“system.web.extensions/scripting/scriptResourceHandler” 解决办法...
查看>>
AIX 7.1 install python
查看>>
PHP盛宴——经常使用函数集锦
查看>>
重写 Ext.form.field 扩展功能
查看>>
Linux下的搜索查找命令的详解(locate)
查看>>
福利丨所有AI安全的讲座里,这可能是最实用的一场
查看>>