Hibernate检索策略

我会带着你远行 2022-07-14 03:00 252阅读 0赞

Hibernate检索策略

  1.  它是为了让我们的查询更加的有效率，是优化我们查询用的。 它是靠配置的方式来实现的

延迟加载

  1.  延迟加载(lazy load)是(也称为懒加载 )Hibernate关联关系对象默认的加载方式，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。
  3.  通常将延迟加载分为两类 :一类叫做类级别延迟 ，另一类叫做关联级别的延迟。类级别的延迟指的是查询某个对象的时候，是否采用有延迟，这个通常在<class>标签上配置lazy属性。关联级别的延迟指的是，查询一个对象的关联对象的时候是否采用延迟加载。这个通 常在<set>或<many-to-one>上配置lazy属性。

类级别的延迟加载

  1.  使用load方法检索某个对象的时候，这个类是否采用延迟加载的策略，就是类级别的延迟。类级别的延迟一般在<class>上配置lazy属性，lazy的默认值是 true 。默认是延迟加载的 ，所以使用 load方法去查询的时候 ，不会马上发送SQL语句。当真正使用该对象的时候，才会发送SQL语句。
  3. Customer customer = session.load(Customer.class,1L);
  5.  其实如果不想使用延迟加载也有很多种方法，当然最简单的就是将这个类的映射文件上的lazy设置为false，当然也可以将这个持久化类改为final修饰，如果改为final修饰的话。就无法生成代理类，就会使延迟加载失效。
  7.  这是类级别的延迟加载， 类级别的延迟加载一般不进行修改 ，采用默认值 lazy="true"就可以了。

关联级别的延迟加载

  1.  关键级别的延迟加载指的是查询到某个对象以后，检索它的关联对象的时候是否采用延迟加载 。
  3. Customer customer = session.get(Customer.class,1L);
  4. Set<LinkMan> linkMans = customer.getLinkMans();
  9.  通过客户查询其关联的联系人对象，在查询联系人的时候是否采用延迟加载称为是关联级别的延迟。关联级别的延迟通常是在<set>和<many-to-one>上来进行配置 。

标签上的lazy通常有三个取值 :

  • true : 默认值，采用延迟加载
  • false: 检索关联对象 的时候，不采用延迟加载 。
  • extra : 极其懒惰的，用到什么加载什么。

标签上的 lazy 通常有三个取值:

  • proxy：默认值，是否采用延迟取决于一的一方类上的lazy属性的值 。
  • false：检索关联对象的时候，不采用延迟加载。
  • no-proxy: 不用研究。

关联级别的抓取策略

  1.  抓取策略指的是查询到某个对象的时候，如何抓取其关联对象。这个也可以通过配置完成 。在关联对象的标签上配置fetch属性。关联上就分为是在<set>和<many-to-one>上，也都有不同的取值 。

标签上的fetch通常有三个取值:

  • select：默认值，发送的是普通的 select 语句查询。
  • join：发送一条迫切左外连接去查询。
  • subselect：发送一条子查询语句查询其关联对象。

标签上的 fetch 有两个取值 :

  • select：默认值，发送一条普通的select 语句查询关联对象。
  • join：发送一条迫切左外连接语句查询其关联对象。
  1.  set上配置fetch有三个值，lazy有三个值，这样就会产生很多种的效果。其实不用担心，因为fetch如果设置为join，lazy就会失效了。
  3.  简单的总结一 下fetch和lazy的作用，其实fetch主要控制抓取关联对象的时候的发送SQL语句的格式的。lazy主要控制查询其关联对象的时候是否采用延迟加载的。

批量抓取

  1.  在抓取的策略中有一种叫做批量抓取，就是同时查询多个对象的关联对象的时候，可以采用批量抓取进行优化 。当然这不是特别的重要。如果要实现批量的抓取效果，可以通过配置batch-size来完成。
  3.  可以在class和set上配置
  • 在一的那方的class配置，表示在查询多方时可以同时获取几个一方的对象。
  • 在一的那方的set上配置，表示在查询一方时可以同时获取几个多方的对象。

实际开发中推荐的取值

  1.  一对多（多对多）的情况：
  3.       lazy：true
  5.       fetch：select
  7.  多对一的情况：
  9.       lazy：false
  11.       fetch：select

一对多（多对多） 情况






















































序号

lazy的取值

fetch的取值

说明（都是以客户订单的一对多关系为例）


1

true（默认值）

select（默认值）

时机：用时才真正去查询订单。


语句形式：有1条查询客户的和多条查询订单的select语句。


batch-size:设置批量检索的深度。（建议3~10之间）


2

false

select（默认值）

时机：不管用不用订单，查询客户时都立即查询订单。


语句形式：有1条查询客户的和多条查询订单的select语句。


batch-size:设置批量检索的深度。（建议3~10之间）


3

extra

select（默认值）

时机：用什么信息，查什么信息。只查询必要的。


语句形式：有1条查询客户的和多条查询订单的select语句。


batch-size:设置批量检索的深度。（建议3~10之间）


4

true

subselect

时机：用时才真正去查询订单。


语句形式：子查询


batch-size：无效


5

false

subselect

时机：不管用不用订单，查询客户时都立即查询订单。


语句形式：子查询


batch-size：无效


6

extra

subselect

时机：用什么信息，查什么信息。只查询必要的。


语句形式：子查询


batch-size：无效


 7

true|false|extra

join（当join有效时，根本不看lazy属性）

时机：无效。因为连接查询，一次就是两张表及以上。


语句：left outer join


batch-size：无效


注意：Query查询会忽略join的存在。当join无效时，lazy就有效了。

多对一（一对一） 情况






























序号

lazy的取值

fetch的取值

说明（都是以客户订单的一对多关系为例）


1

proxy

select

时机：


    对象类级别的策略：true。


延迟加载。得到的是代理对象。


    对象类级别的策略：false。


立即加载。得到就是类对象。


语句：


    多条SQL语句


2

false

select

时机：立即加载。与对象类级别的策略无关。


语句：多条SQL语句。


3

true|false|extra

join（当join有效时，根本不看lazy属性）

时机：无效。因为连接查询，一次就是两张表及以上。


语句：left outer join


batch-size：无效


注意：Query查询会忽略join的存在。当join无效时，lazy就有效了。

测试Hibernate检索策略 

  1. package com.pc.hibernate.test.querystrategy;
  3. import java.util.List;
  5. import org.hibernate.Query;
  6. import org.hibernate.Session;
  7. import org.hibernate.Transaction;
  8. import org.junit.Test;
  10. import com.pc.hibernate.domain.Customer;
  11. import com.pc.hibernate.domain.LinkMan;
  12. import com.pc.hibernate.utils.HibernateUtils;
  14. /**
  15.  * Hibernate的检索策略
  16.  *     明确：
  17.  *         它是为了让我们的查询更加的有效率，是优化我们查询用的。
  18.  *         它是靠配置的方式来实现的。
  19.  *  关联级别的检索策略关心的是：
  20.  *      实体类中的那个关联对象。
  21.  *      例如：
  22.  *          客户实体类中，关心的是联系人
  23.  *          联系人实体类中，关心的是客户
  24.  *          用户实体类中，关心的是角色   
  25.  *             角色实体类中，关心的是用户
  26.  *  类级别检索策略关心的是：
  27.  *      是当前实体类中所对应数据库表中所包含字段。
  28.  *  类级别解决的问题：
  29.  *      什么时候真正去查询，查询实体类中除了OID外的其他字段信息。
  30.  * 
  31.  *  关联级别的检索策略解决的问题：（从哪些方面优化）
  32.  *      1、查询的时机：
  33.  *          到底什么时候真正的去查询
  34.  *          立即加载
  35.  *          延迟加载：惰性加载，懒加载
  36.  *      2、采用什么方式去查询
  37.  *           多条SQL语句
  38.  *          子查询
  39.  *          表连接
  40.  *  关联级别的检索策略分几种情况：
  41.  *      分为两种情况：
  42.  *          一对多和多对多：
  43.  *              有少的一方，根据少的一方获取多的一方。
  44.  *          多对一和一对一
  45.  *              有多的一方，根据多的一方获取少的一方。
  46.  *  关联级别涉及的配置
  47.  *      一对多（多对多）情况：
  48.  *          涉及的标签：set
  49.  *          涉及的属性：lazy：什么时候去查询
  50.  *                      取值：
  51.  *                          true：延迟加载（默认值）
  52.  *                          false：立即加载
  53.  *                          extra：极懒加载    用什么数据，查什么数据，不用的都不查
  54.  *                   fetch：用什么方式去查询
  55.  *                      取值：
  56.  *                          select:多条SQL语句（默认值）
  57.  *                          subselect:子查询
  58.  *                          join:表连接
  59.  *      多对一（一对一）情况：
  60.  *          涉及的标签:many-to-one
  61.  *          涉及的属性：lazy：什么时候去查询
  62.  *                      false：立即加载
  63.  *                      proxy：看关联对象的类级别检索策略
  64.  *                      no-proxy：不用管，实际开发根本不用
  65.  *                  fetch：用什么方式去查询
  66.  *                      select：多条SQL语句
  67.  *                      join：表连接
  68.  *             
  69.  *     
  70.  *  实际开发中：
  71.  *      一对多（多对多）的情况：
  72.  *          lazy：用true
  73.  *          fetch:用select
  74.  *      多对一的情况：
  75.  *          lazy:false
  76.  *          fetch:select
  77.  *
  78.  * @author Switch
  79.  *
  80.  */
  81. public class TestQueryStrategy1 {
  82.     /**
  83.      * 需求：
  84.      *     查询id为1的客户下的所有联系人
  85.      * 查询的时机：
  86.      *       延迟加载
  87.      * 查询的方式：
  88.      *        多条语句。2条，一条查询了客户，一条查询了联系人
  89.      */
  90.     @Test
  91.     public void test1(){
  92.         Session session = HibernateUtils.getCurrentSession();
  93.         Transaction tx = session.beginTransaction();
  95.         //1.查询id为1的客户
  96.         Customer customer = session.get(Customer.class, 1L);
  98.         //2.使用对象导航查询，查询该客户的联系人
  99.         //类级别检索策略
  100.         System.out.println(customer);
  101.         System.out.println(customer.getLinkMans().size());
  102.         //关联级别检索策略
  103.         System.out.println(customer.getLinkMans());
  104.         tx.commit();
  105.     }
  107.     /**
  108.      * 需求：
  109.      *     查询所有客户，获取每个客户的联系人
  110.      * 查询的时机
  111.      *         延迟加载
  112.      * 查询的方式
  113.      *         多条语句。5条SQL语句。查询联系人只有4条语句，还有一条是查询客户的。
  114.      *         Hibernate的N+1问题：
  115.      *             当我们查询一个从表关联对象集合时，正常查询应该是N条语句，但是由于需要查询主表，所以会多出一条语句。
  116.      *         解决N+1问题：
  117.      *             在Hibernate的映射配置文件中，添加一个batch-size属性。该属性的含义：批量抓取。简单的说就是问号的个数。
  118.      *         batch-size属性的取值：建议3~10之间。
  119.      */
  120.     @Test
  121.     public void test2(){
  122.         Session session = HibernateUtils.getCurrentSession();
  123.         Transaction tx = session.beginTransaction();
  124.         //1.查询所有客户
  125.         Query query = session.createQuery("from Customer");
  126.         @SuppressWarnings("unchecked")
  127.         List<Customer> customers = query.list();
  128.         for (Customer customer : customers) {
  129.             //2.使用对象导航查询，查询该客户的联系人
  130.             //类级别检索策略
  131.             System.out.println(customer);
  132.             //关联级别检索策略
  133.             System.out.println(customer.getLinkMans());
  134.         }
  135.         tx.commit();
  136.     }
  139.     /**
  140.      * 需求：
  141.      *     查询id为1的联系人的所属客户
  142.      * 查询的时机：false
  143.      *         立即加载
  144.      * 查询的方式：select
  145.      *         多条语句
  146.      */
  147.     @Test
  148.     public void test3(){
  149.         Session session = HibernateUtils.getCurrentSession();
  150.         Transaction tx = session.beginTransaction();
  151.         //1.查询id为1的联系人
  152.         LinkMan l1 = session.get(LinkMan.class, 1L);
  153.         //2.使用对象导航查询，获取该联系人的客户
  154.         System.out.println(l1);
  155.         System.out.println(l1.getCustomer());
  156.         tx.commit();
  157.     }
  159.     /**
  160.      * 需求：
  161.      *     查询id为1的联系人的所属客户
  162.      * 查询的时机：proxy
  163.      *         看关联对象的类级别检索策略
  164.      * 查询的方式：select
  165.      *         多条语句
  166.      */
  167.     @Test
  168.     public void test4(){
  169.         Session session = HibernateUtils.getCurrentSession();
  170.         Transaction tx = session.beginTransaction();
  171.         //1.查询id为1的联系人
  172.         LinkMan l1 = session.get(LinkMan.class, 1L);
  173.         //2.使用对象导航查询，获取该联系人的客户
  174.         System.out.println(l1);
  175.         System.out.println(l1.getCustomer());
  176.         tx.commit();
  177.     }
  178. }

Customer.hbm.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  4.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  5.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  6. <!--
  7. 1、导入dtd约束
  8.      在Hibernate的核心jar包中：hibernate-mapping-3.0.dtd
  9. 2、编写配置文件
  10.           实体类和数据库表的对应关系
  11.           实体类中属性和表的字段的对应关系
  12.  -->
  13. <hibernate-mapping package="com.pc.hibernate.domain">
  14.      <!-- class标签：
  15.               作用：用于配置实体类和表之间的对应关系
  16.               属性：
  17.                    name:实体类的名称。它应该写全限定类名
  18.                    table:数据库表的名称
  19.      -->
  20.      <class name="Customer" table="cst_customer" lazy="true" batch-size="3">
  21.           <!-- id标签：
  22.                    作用：映射主键
  23.                    属性：
  24.                         name：实体类的属性名称
  25.                         column：数据库表的字段名称
  26.                         type：主键的类型
  27.           -->
  28.           <id name="custId" column="cust_id" type="java.lang.Long">
  29.               <!-- generator标签：
  30.                         作用：主键的生成方式
  31.                         属性：
  32.                              class：指定方式
  33.                              取值：native
  34.                                   含义：使用本地数据库的自动增长能力。
  35.               -->
  37.               <generator class="native"/>
  38.           </id>
  39.           <!-- property标签：
  40.                    作用：映射其他字段
  41.                    属性：
  42.                         name：实体类的属性名称
  43.                         column：数据库表的字段名称
  44.                         type：字段的类型
  45.                         length：数据库中对应列的长度
  46.           -->
  47.           <property name="custName" column="cust_name" type="java.lang.String" length="32"/>
  48.           <property name="custSource" column="cust_source" type="java.lang.String" length="32"/>
  49.           <property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/>
  50.           <property name="custLevel" column="cust_level" type="java.lang.String" length="32"/>
  51.           <property name="custAddress" column="cust_address" type="java.lang.String" length="128"/>
  52.           <property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/>
  54.           <!-- 配置一对多 -->
  55.           <set name="linkMans" inverse="false" cascade="save-update" batch-size="4" lazy="true" fetch="select">
  56.               <key column="lkm_cust_id" />
  57.               <one-to-many class="LinkMan"/>
  58.           </set>
  59.      </class>
  60. </hibernate-mapping>

LinkMan.hbm.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  4.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  5.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping package="com.pc.hibernate.domain">
  7.      <class name="LinkMan" table="cst_linkman">
  8.           <id name="lkmId" column="lkm_id" type="java.lang.Long">
  9.               <generator class="native" />
  10.           </id>
  11.           <property name="lkmName" column="lkm_name" type="java.lang.String" length="16"/>
  12.           <property name="lkmGender" column="lkm_gender" type="java.lang.String" length="10"/>
  13.           <property name="lkmPhone" column="lkm_phone" type="java.lang.String" length="16"/>
  14.           <property name="lkmMobile" column="lkm_mobile" type="java.lang.String" length="16"/>
  15.           <property name="lkmEmail" column="lkm_email" type="java.lang.String" length="64"/>
  16.           <property name="lkmPosition" column="lkm_position" type="java.lang.String" length="16"/>
  17.           <property name="lkmMemo" column="lkm_memo" type="java.lang.String" length="512"/>
  19.           <!-- 配置多对一 -->
  20.           <many-to-one name="customer" class="Customer" column="lkm_cust_id" cascade="save-update" lazy="proxy" fetch="select"/>
  21.      </class>
  22. </hibernate-mapping>

hibernate.cfg.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.      "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.      "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <!-- 1、导入dtd约束 在hibernate核心jar包中：hibernate-configuration-3.0.dtd 2、编写配置文件 -->
  6. <hibernate-configuration>
  7.      <!-- 配置SessionFactory -->
  8.      <!-- 创建SessionFactory需要3部分信息。 而配置文件中要写哪些配置，我们可以翻阅资料。 -->
  9.      <!-- 第一部分：连接数据库的基本信息,第二部分：hibernate的基本配置,第三部分：映射文件的位置 -->
  10.      <session-factory>
  11.           <!-- 1、连接数据库的基本信息 -->
  12.           <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  13.           <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mycrm</property>
  14.           <property name="hibernate.connection.username">root</property>
  15.           <property name="hibernate.connection.password">123456</property>
  17.           <!-- 数据库的方言 -->
  18.           <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  20.           <!-- 2、hibernate的基本配置 -->
  21.           <!-- 是否显示SQL语句 -->
  22.           <property name="hibernate.show_sql">true</property>
  23.           <!-- 是否格式化显示SQL语句 -->
  24.           <!-- <property name="hibernate.format_sql">true</property> -->
  25.           <!-- 采用何种策略来创建表结构： -->
  26.           <!-- update：检查表结构和实体类映射文件的变化，如果发现映射文件和表结构不一致，更新表结构。 -->
  27.           <!-- 注意：hibernate不能创建数据库，只能在有数据库的情况下创建表结构。 -->
  28.           <property name="hibernate.hbm2ddl.auto">update</property>
  30.           <!-- 配置hibernate使用连接池：告知Hibernate使用连接池的厂商 -->
  31.           <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
  33.           <!-- 配置把Session绑定到当前线程上，从而保证一个线程只有一个Session -->
  34.           <property name="hibernate.current_session_context_class">thread</property>
  36.           <!-- 3、映射文件的位置 -->
  37.           <mapping resource="com/pc/hibernate/domain/Customer.hbm.xml" />
  38.           <mapping resource="com/pc/hibernate/domain/LinkMan.hbm.xml" />
  39.      </session-factory>
  40. </hibernate-configuration>

发表评论

表情：
评论列表 （有 0 条评论，252人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Hibernate检索策略

    检索策略追求的两个目标是：（以客户和订单的例子说明） 不浪费内存：当Hibernate从数据库中加载Customer对象时，如果同时加载所有关联的Order对象，而程序

    今天药忘吃喽~今天药忘吃喽~/ 0 赞/ 254 阅读

    相关 Hibernate检索策略

           有一对有关联关系的对象A和B，在运行Query.list()方法时，先查出A记录，然后遍历A的id去B中查询。这种策略为立即检索策略。这种策略有两处缺点。一处是s

    系统管理员系统管理员/ 0 赞/ 231 阅读

    相关 Hibernate -- 检索

    Hibernate 的检索方式 在实际开发项目时，对数据进行最多的操作就是查询，数据的查询在所有 ORM 框架中都占有极其重要的地位。那么，如何利用 Hibernate

    蔚落蔚落/ 0 赞/ 305 阅读