一对多 、多对多 的检索策略

最新推荐文章于 2023-03-23 23:19:01 发布
最新推荐文章于 2023-03-23 23:19:01 发布
阅读量1.1k 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuck_kui/article/details/51588673
版权
在映射文件中, 用 <set> 元素来配置一对多关联及多对多关联关系. <set> 元素有 lazy 和 fetch 属性
lazy: 主要决定 orders 集合被初始化的时机. 即到底是在加载 Customer 对象时就被初始化, 还是在程序访问                   orders 集合时被初始化
fetch: 取值为 “select” 或 “subselect” 时, 决定初始化 orders 的查询语句的形式;  若取值为”join”, 则决定 orders            集合被初始化的时机若把 fetch 设置为 “join”, lazy 属性将被忽略

<set> 元素的 batch-size 属性：用来为延迟检索策略或立即检索策略设定批量检索的数量. 批量检索能减少                                                                SELECT 语句的数目, 提高延迟检索或立即检索的运行性能. 


Clazz 类 的对象关系映射，之一中的set 属性中的配置

<hibernate-mapping package="com.baidu.setStrategy">
			<!-- lazy 类级别的懒加载 -->
    <class name="Clazz" table="CLAZZS" >
    
        <id name="clazzId" type="java.lang.Integer">
            <column name="CLAZZ_ID" />
            <generator class="native" />
        </id>
        
        <property name="clazzName" type="java.lang.String">
            <column name="CLAZZ_NAME" />
        </property>
        
        <set name="stus" table="STUDENTS" lazy="true">
            <key>
                <column name="CLAZZ_ID" />
            </key>
            <one-to-many class="Student" />
        </set>
        
    </class>
    
</hibernate-mapping>

	/**
	 * Set 的 lazy 属性
	 * 	1.  1-n 或n-n 的集合属性默认使用懒加载检索策略
	 *  2.  可以通过设置set 的lazy 属性来修改默认的检索策略，默认为true
	 *  	并不建议设置为false
	 *  3.  lazy 还可以设置为extra，增强的延迟检索。该取值会尽可能的延迟集合初始化的时机
	 * 	4.	Hibernate.initialize() 静态方法显式初始化
	 */

Lazy 属性：默认值是true

① 当取true 时， 

	@Test
	public void testOne2ManyLevelStrategy() {
		Clazz clazz =(Clazz) session.get(Clazz.class, 1); 
		System.out.println(clazz.getClass());
		
		System.out.println(clazz.getStus().size());
	
	}
运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_0_ 
    from
        CLAZZS clazz0_ 
    where
        clazz0_.CLAZZ_ID=?
class com.baidu.setStrategy.Clazz
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2

② 当取fasle 时，
运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_0_ 
    from
        CLAZZS clazz0_ 
    where
        clazz0_.CLAZZ_ID=?
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
class com.baidu.setStrategy.Clazz
2

③ 当取extra 时，

运行的SQL

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_0_ 
    from
        CLAZZS clazz0_ 
    where
        clazz0_.CLAZZ_ID=?
class com.baidu.setStrategy.Clazz
Hibernate: 
    select
        count(STU_ID) 
    from
        STUDENTS 
    where
        CLAZZ_ID =?
2
在添加测试方法中添加代码 

	@Test
	public void testOne2ManyLevelStrategy() {
		Clazz clazz =(Clazz) session.get(Clazz.class, 1); 
		System.out.println(clazz.getClass());
		System.out.println(clazz.getStus().size());
		
	
		Student student = new Student();
		
		student.setStuId(1);
		System.out.println(clazz.getStus().contains(student));
		
	}
运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_0_ 
    from
        CLAZZS clazz0_ 
    where
        clazz0_.CLAZZ_ID=?
class com.baidu.setStrategy.Clazz
Hibernate: 
    select
        count(STU_ID) 
    from
        STUDENTS 
    where
        CLAZZ_ID =?
2
Hibernate: 
    select
        1 
    from
        STUDENTS 
    where
        CLAZZ_ID =? 
        and STU_ID =?
true
④ 当使用Hibernate.initialize() 静态方法 时 

	@Test
	public void testOne2ManyLevelStrategy() {
		Clazz clazz =(Clazz) session.get(Clazz.class, 1); 
		System.out.println(clazz.getClass());
		System.out.println(clazz.getStus().size());
		
	
		Student student = new Student();
		
		student.setStuId(1);
		System.out.println(clazz.getStus().contains(student));
		
		Hibernate.initialize(clazz.getStus());
		
	}
运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_0_ 
    from
        CLAZZS clazz0_ 
    where
        clazz0_.CLAZZ_ID=?
class com.baidu.setStrategy.Clazz
Hibernate: 
    select
        count(STU_ID) 
    from
        STUDENTS 
    where
        CLAZZ_ID =?
2
Hibernate: 
    select
        1 
    from
        STUDENTS 
    where
        CLAZZ_ID =? 
        and STU_ID =?
true
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?


	/**
	 * Set 的 batch-size 属性: 设定一次初始化 set 集合的数量
	 */
 batch-size 属性 

	@Test
	public void testSetBatchSize() {
		List<Clazz> clazzs = session.createQuery("FROM Clazz").list();
		System.out.println(clazzs.size());
		
		for(Clazz clazz:clazzs ){
			if(clazz.getStus() != null)
				System.out.println(clazz.getStus().size());
		}
	}
① 当没有使用batch-size 属性时，

运行的SQL

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_ 
    from
        CLAZZS clazz0_
3
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2
当在clazz的配置文件的set属性中添加 batch-size = "5" ：表示一次初始化5条记录 

        <set name="stus" table="STUDENTS" lazy="true" batch-size="5">
            <key>
                <column name="CLAZZ_ID" />
            </key>
            <one-to-many class="Student" />
        </set>

运行的SQL

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_ 
    from
        CLAZZS clazz0_
3
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID in (
            ?, ?, ?
        )
2
2
2

fetch属性: 取值为 “select” 或 “subselect” 时, 决定初始化 students 的查询语句的形式;  

                   若取值为”join”, 则决定orders 集合被初始化的时机

	/**
	 * Set 的 fetch 属性: 
	 * 	1. 默认值为select：通过正常的方式来初始化set元素
	 *  2. 可以取值subselect： 
	 *  	① 通过子查询的方式来初始化所有的 set 集合。子查询作为where 子句的 in的条件出现，
	 *  		子查询查询所有1 的一端的ID
	 *      ② 此时lazy 有效，但是batch-size 属性将被忽略，不再起作用。
	 */

	/**
	 * Set 的 fetch 属性: 
	 * 	3. 可以取值为join:  batch-size有效
	 * 		① 在加载 1 的一端的对象时，使用迫切左外连接的方式检索 n 的一端的集合属性
	 * 
	 * 		② 会忽略lazy 属性
	 * 		
	 * 		③ 使用HQL 查询时，会 忽略fetch=join
	 * 		
	 * 		
	 * 迫切左外连接：使用左外连接进行查询，且把集合属性进行初始化
	 */

fetch: 
         ①取值为 select 

        <set name="stus" table="STUDENTS" 
        lazy="true" batch-size="2" fetch="subselect">
            <key>
                <column name="CLAZZ_ID" />
            </key>
            <one-to-many class="Student" />
        </set>

	@Test
	public void testSetFetchSelectOrSubselect() {
		
		List<Clazz> clazzs = session.createQuery("FROM Clazz").list();
		System.out.println(clazzs.size());
		
		for(Clazz clazz:clazzs ){
			if(clazz.getStus() != null)
				System.out.println(clazz.getStus().size());
		}
	}
运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_ 
    from
        CLAZZS clazz0_
3
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID in (
            ?, ?
        )
2
2
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2

        ② 取值为usubselect

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_ 
    from
        CLAZZS clazz0_
3
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID in (
            select
                clazz0_.CLAZZ_ID 
            from
                CLAZZS clazz0_
        )
2
2
2
         ③ 取值为 join 
        <set name="stus" table="STUDENTS" 
        lazy="true" batch-size="2" fetch="join">
            <key>
                <column name="CLAZZ_ID" />
            </key>
            <one-to-many class="Student" />
        </set>
	@Test
	public void testSetFetchJoin() {
		
		Clazz clazz = (Clazz) session.get(Clazz.class, 1);
		System.out.println(clazz.getStus().size());
		
		
	}


运行的SQL

使用HQL 查询时，batch-size有效， 但会 忽略fetch=join ,

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_ 
    from
        CLAZZS clazz0_
3
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID in (
            ?, ?
        )
2
2
Hibernate: 
    select
        stus0_.CLAZZ_ID as CLAZZ_ID3_0_1_,
        stus0_.STU_ID as STU_ID1_1_1_,
        stus0_.STU_ID as STU_ID1_1_0_,
        stus0_.STU_NAME as STU_NAME2_1_0_ 
    from
        STUDENTS stus0_ 
    where
        stus0_.CLAZZ_ID=?
2

	@Test
	public void testSetFetchJoin() {
		
		Clazz clazz = (Clazz) session.get(Clazz.class, 1);
		System.out.println(clazz.getStus().size());
		
		
	}

运行的SQL 

Hibernate: 
    select
        clazz0_.CLAZZ_ID as CLAZZ_ID1_0_1_,
        clazz0_.CLAZZ_NAME as CLAZZ_NA2_0_1_,
        stus1_.CLAZZ_ID as CLAZZ_ID3_0_3_,
        stus1_.STU_ID as STU_ID1_1_3_,
        stus1_.STU_ID as STU_ID1_1_0_,
        stus1_.STU_NAME as STU_NAME2_1_0_ 
    from
        CLAZZS clazz0_ 
    left outer join
        STUDENTS stus1_ 
            on clazz0_.CLAZZ_ID=stus1_.CLAZZ_ID 
    where
        clazz0_.CLAZZ_ID=?
2




chuck_kui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate的检索策略-一对多和多对多关联
ylw620的专栏
05-07 1229
元素来配置一对多或多对多的关联关系，元素有lazy和outer-join的属性立即检索 如果一对的很多的情况下使用了立即检索的策略就会浪费大量的内存空间，所以一对多的关联不可随意使用立即检索策略延迟检索 应该优先考虑延迟检索批量延迟检索和批量立即检索 设定batch_size属性.在sql语句中会使用or进行批量初始化,batch_size属性不宜设置太大，如果设置太大就会使延迟加载失
多对一和一对一关联的检索策略
奔跑在路上
06-05 695
元素也有一个 lazy 属性和 fetch 属性. <many-to-one name="person" class
吴恩达机器学习笔记--第三周-3.多类别分类：一对多策略
野心家-Andy的博客
04-20 2259
week3-3.Multiclass Classification：One-vs-all对于一个三元分类问题，可以转化为三个二元分类问题。对每个二元分类问题设计假设函数h(x)，并对数据集进行0-1标记。三个二元分类都训练好后，对于新输入的测试样本x，分别投到三个二分类假设函数中算出h值，随后选最大h值所对应的类别。...
Hibernate5-1对多(1:n)-fetch="select"-lazy="extra"
weixin_34318956的博客
11-12 156
1.创建项目,项目名称hibernatedemo25,目录结构如图所示 2.在项目中创建lib目录存储jar文件,目录结构如图所示 3.在src目录中创建实体类Forum,包名(com.mycompany.demo.bean),如图所示 4.实体类Forum的内容如下 packagecom.mycompany.demo.bean; imp...
Hibernate级联操作，一对多、多对多、延迟加载lazy=“true“,proxy, no-proxy
可控的事情要谨慎，不可控的事情要乐观。
08-16 297
主流 ORM 框架 Object Relation Mapping 对象关系映射，将⾯向对象映射成⾯向关系。 如何使⽤ 1、导⼊相关依赖 2、创建 Hibernate 配置⽂件 3、创建实体类 4、创建实体类-关系映射⽂件 5、调⽤ Hibernate API 完成操作 具体操作 1、创建 Maven ⼯程，pom.xml <dependencies> <dependency> <groupId>mysql</groupId> <artifac
人工智能-多模态检索-基于深度学习的影像学报告多模态检索
最新发布
05-08
在影像学报告的检索中，深度学习模型可以学习到图像中的结构特征和文本中的语义信息，从而实现对病患状况的有效表示。 具体到“基于深度学习的影像学报告多模态检索”项目，可能涉及以下几个关键知识点： 1. **...
行业分类-设备装置-一种多媒体信息检索的方法.zip
08-20
通过实验和数据分析，可以不断调整检索策略，提高用户满意度。 在“一种多媒体信息检索的方法.pdf”这个文档中，很可能会详细阐述上述的某一部分或全部过程，包括具体的方法论、算法实现、实验结果以及可能的应用...
行业分类-设备装置-一种多媒体信息模糊检索方法.zip
08-20
描述中的信息与标题相同，再次强调了主题是关于多媒体信息的模糊检索方法，可能包含对这种方法的理论介绍、实现原理、应用实例或者优化策略等内容。 标签“行业分类-设备装置-一种多媒体信”是对主题的进一步细化，...
信息检索实验报告，多个
02-16
这份实验报告涵盖了多个信息检索的实例，旨在通过实践加深对这一关键领域的理解。下面，我们将详细探讨信息检索的重要概念、技术和应用。 信息检索的核心是建立一个能够快速、准确地查找所需信息的系统。在传统意义...
数据库检索策略初步.ppt
12-14
总之，数据库检索策略是一项综合技能，涉及到对数据库结构的理解、检索词的选取、检索项的应用以及逻辑运算符的合理运用。通过熟练掌握这些知识，用户可以在海量的信息中迅速、准确地找到所需资料，为科研和学习提供...
织梦DEDE分类信息实现联动筛选（支持多条件多级选项）解决方案
塔夏时光的博客
05-30 8019
   很多织梦建站的站长在做产品列表页的时候，产品分类多而且都是关联的，用户不能快速的找到自己需要的东西，很多情况下都需要用到筛选功能，织梦后台列表页默认是没有联动筛选功能，实现这个联动筛选功能需要对织梦进行二次开发，接下来教大家如何实现这个联动筛选功能，如下图所示：注：因为织梦默认是禁止使用php标签，所以需要在后台模板引擎禁用标签里面解除这个标签的禁用，具体方法：后台——系统——系统基本参数—...
数据库中“一对一”、“一对多”、“多对多”的判断方法
CapMiachael的博客
05-30 1万+
数据库中“一对一”、“一对多”、“多对多”的判断方法 多对多：一个老师可以教多个学生，一个学生可以有多个老师教。 一对多：一个父亲可以有多个亲生孩子，一个孩子只能有一个生父。 一对一：一个人只能有一张身份证，一张身份证对应的人也是唯一的。 很好区分：假设A，B两实体，先看A能推出B是1:1还是1:n,再开B能推出A看是1:1还是1：n， 如果两边都是1:1难么A和B为一对一； 如果两边...
MySQL表设计思路（一对多、多对多...）
llg___的博客
03-23 5605
一对多，两张表，多的表加外键多对多，三张表，关系表加外键命名规范，表名以t_或者tbl_开头，增加可读性，字段采用下划线命名，避免用保留字，如select、desc主键索引名为pk_字段名，唯一索引名为uk_字段名，普通索引名为idx_字段名数据类型选择时，金额类不能选择float、double，选decimal，防止精度丢失主键的设计最好设业务主键，最好是一串无意义且不重复的数字，可采用UUID或者Auto_increment自增。
【转】数据库一对一、一对多、多对多关系
beidaol的专栏
11-01 1万+
转自：https://blog.csdn.net/u013144287/article/details/79024130  本来数据库一对一、一对多、多对多关系并不复杂，但是最近在理解的时候感觉又感觉多了写新意，所以现在在来总结一下吧 一、首先给出三种关系的实例 1、一对一关系实例    * 一个人对应一张身份证，一张身份证对应一个人 2、一对多关系实例    * 一个班级拥有多个学生，一个学生...
Hibernate中的一对多&多对一&关联&级联
hongcaixia的博客
01-23 2085
domain: Customer: package com.hcx.domain; import java.util.HashSet; import java.util.Set; public class Customer { private Integer id; private String name; //在1 的一方,表达持有多的一方的引用=>使用集合 pri...
数据库一对一、一对多、多对多关系
热门推荐
诗雨远方的博客
01-10 11万+
数据库一对一、一对多、多对多关系      本来数据库一对一、一对多、多对多关系并不复杂，但是最近在理解的时候感觉又感觉多了写新意，所以现在在来总结一下吧 一、首先给出三种关系的实例 1、一对一关系实例    * 一个人对应一张身份证，一张身份证对应一个人 2、一对多关系实例    * 一个班级拥有多个学生，一个学生只能够属于某个班级 3、多对多实例    * 一个学生可以
JAVA 类集一对多多对多的实例
qq_43233736的博客
11-14 2916
package petshop; import java.util.Iterator; import java.util.Set; import java.util.List; import java.util.ArrayList; class Student{ private String name; private int age; private School ...
数据库实体间多对多关系处理
iteye_1907的博客
08-22 2628
 数据库实体间多对多关系处理   数据库实体间有三种对应关系：一对一，一对多，多对多。 一对一关系示例：一个学生对应一个学生档案材料，或者每个人都有唯一的身份证编号。 一对多关系示例：一个学生只属于一个班，但是一个学院有多名学生。 多对多关系示例：一个学生可以选择多门课，一门课也有多名学生。   这三种关系在数据库中逻辑结构处理分析：   1.一对多关系处理： 我们以学生和班级...
Hibernate一对多与多对多检索策略详解
"本文主要探讨了在Hibernate框架中一对多和多对多的检索策略，以及hbm2ddl.auto属性的四种取值含义，并提到了1-1关联的延迟加载策略配置。" 在Hibernate框架中，一对多和多对多关联是数据库关系映射的重要组成部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值