08-Hibernate类级别加载策略，关联级别策略

最新推荐文章于 2020-05-12 19:47:56 发布
最新推荐文章于 2020-05-12 19:47:56 发布
阅读量210 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26270869/article/details/90200012
版权

08-Hibernate类级别加载策略，关联级别策略

  • 类级别加载策略

    1. get方法：立即加载。执行方法时立即发送SQL语句查询结果

      <class name="Customer" table="cst_customer" lazy="true">

      @Test
	//get方法：立即加载。执行方法时立即发送SQL语句查询结果
	public void fun1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.get(Customer.class, 2l);
		
		System.out.println(c);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}

    2. load方法（默认）：是在执行时，不发送任何sql语句，返回一个对象，使用该对象时，才执行查询。

      1. 延迟加载：仅仅获取没有使用，不会查询，在使用时才会进行查询
      2. 是否对类进行延迟加载，： 可以通过在class元数据上配置lazy属性来控制
      3. lazy:true 加载时，不查询，使用时才查询
      4. lazy:false 加载时立即查询
      5. 结论：为了提高效率。建议使用延迟加载(懒加载)
      6. 注意：使用懒加载时要确保调用属性加载数据时，session还是打开的，否则会抛出org.hibernate.LazyInitializationException: could not initialize proxy - no Session
      @Test
	//load方法（默认）：是在执行时，不发送任何sql语句，返回一个对象，使用该对象时，才执行查询。
	//延迟加载：仅仅获取没有使用，不会查询，在使用时才会进行查询
	//是否对类进行延迟加载，： 可以通过在class元数据上配置lazy属性来控制
		//lazy:true 加载时，不查询，使用时才查询
		//lazy:false 加载时立即查询
	public void fun2(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.load(Customer.class, 2l);
		
		System.out.println(c);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}

  • 关联级别策略

    • 集合策略

      • lazy属性：决定是否延迟加载

        1. true（默认值）: 延迟加载,使用时，才加载集合数据
        2. false: 立即加载
        3. extra: 及其懒惰

      • fetch属性： 决定加载策略，使用什么类型的sql语句加载集合

        1. select（默认值）: 单表查询加载
        2. join：使用多表查询加载集合
        3. subselect：使用子查询加载集合
        <set name="linkMens" lazy="extra" fetch="subselect">

        //关联级别延迟加载&抓取策略
public class Demo {
	@Test
	//集合级别的关联
	//fecth:select
	//lazy:true 使用时，才加载集合数据
	public void fun1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.get(Customer.class, 2l);
		
		Set<LinkMan> linkmans = c.getLinkMans();//级别关联
		
		System.out.println(linkmans);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:select
	//lazy:false 立即加载集合数据
	public void fun2(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.get(Customer.class, 2l);
		
		Set<LinkMan> linkmans = c.getLinkMans();//级别关联
		
		System.out.println(linkmans);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:select
	//lazy:extra 极其懒惰,与懒惰加载结果基本一致，如果只获得集合的size，只会查询集合的size（count语句）
	public void fun3(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.get(Customer.class, 2l);
		
		Set<LinkMan> linkmans = c.getLinkMans();//级别关联
		
		System.out.println(linkmans.size());
		
		System.out.println(linkmans);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:join 多表查询
	//lazy:true|false|extra 失效。立即加载
	public void fun4(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		Customer c = session.get(Customer.class, 2l);
		
		Set<LinkMan> linkmans = c.getLinkMans();//级别关联
		
		System.out.println(linkmans.size());
		
		System.out.println(linkmans);
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:subselect 子查询
	//lazy:true  懒加载
	public void fun5(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		String hql ="from Customer";
		
		Query query = session.createQuery(hql);
		List<Customer> list = query.list();
		for(Customer c:list){
			System.out.println(c);
			System.out.println(c.getLinkMans().size());
			System.out.println(c.getLinkMans().size());
		}
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:subselect 子查询
	//lazy:false 立即加载
	public void fun6(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		String hql ="from Customer";
		
		Query query = session.createQuery(hql);
		List<Customer> list = query.list();
		for(Customer c:list){
			System.out.println(c);
			System.out.println(c.getLinkMans().size());
			System.out.println(c.getLinkMans().size());
		}
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
	//集合级别的关联
	//fecth:subselect 子查询
	//lazy:extra  极其懒惰加载
	public void fun7(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		String hql ="from Customer";
		
		Query query = session.createQuery(hql);
		List<Customer> list = query.list();
		for(Customer c:list){
			System.out.println(c);
			System.out.println(c.getLinkMans().size());
			System.out.println(c.getLinkMans().size());
		}
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
}

    • 对象策略

      结论：为了提高效率，fetch的选择上应该选择select，lazy的取值应该选择true（全部使用策略值）

      • lazy属性：决定是否延迟加载

        1. false ： 立即加载
        2. proxy ： 由customer的类级别加载策略决定

      • fetch属性： 决定加载策略，使用什么类型的sql语句加载集合

        1. select：使用单表查询
        2. join：多表查询,(当使用fetch属性使用join时，lazy属性处于失效状态)
        <many-to-one name="customer" column="lkm_cust_id" class="com.qingzi.domain.Customer" lazy="false" fetch="join"></many-to-one>

        //关联级别 延迟加载 & 抓取策略
public class Demo2 {
	@Test
    //集合级别的关联
	//fetch:select 单表查询
	//lazy:proxy 
	//customer -true 使用懒加载
	public void fun1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		
		LinkMan lm = session.get(LinkMan.class, 1l);
		
		Customer customer = lm.getCustomer();
		
		System.out.println(customer);
		
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
    //集合级别的关联
	//fetch:select 单表查询
	//lazy:proxy 
	//customer -false 立即加载
	public void fun2(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		
		LinkMan lm = session.get(LinkMan.class, 1l);
		
		Customer customer = lm.getCustomer();
		
		System.out.println(customer);
		
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
	
	@Test
    //集合级别的关联
	//fetch:join 多表查询
	//lazy:失效状态
	public void fun3(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		
		LinkMan lm = session.get(LinkMan.class, 1l);
		
		Customer customer = lm.getCustomer();
		
		System.out.println(customer);
		
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
}

    • no-session问题的解决

      扩大session的作用范围（如图所示）

    • 抓取策略优化

      • batch-size: 抓取集合的数量为3,抓取客户集合时，一次抓取几个客户的联系人的集合
      <set name="linkMens" batch-size="3">

      //抓取数量
public class Demo {
	@Test
	//集合级别的关联
	//fecth:select
	//lazy:true 使用时，才加载集合数据
	public void fun1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		//---------------------------------------------------------
		String hql = "from Customer";
		Query query = session.createQuery(hql);
		List<Customer> list = query.list();
		
		for(Customer c: list){
			System.out.println(c.getLinkMans());
		}
		//----------------------------------------------------------
		tx.commit();
		session.close();
	}
}
战神清子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate中的加载策略
Hatty1920的博客
12-16 197
文章目录前言一、两种级别的加载策略二、关联级别的加载策略（一对多）1. lazy属性和fetch属性2. lazy属性和fetch属性的组合情况三、在many-to-one标签中（多对一）总结 前言 这一篇主要记录了Hibernate中的加载策略，通过在xml中的不同配置，我们可以设置不同的加载策略。加载策略一般分为延迟加载和立即加载，延迟加载是在使用的时候才会加载数据，立即加载是不管使用不使用，都会立刻加载数据。 一、两种级别的加载策略 加载策略分为类级别加载策略和关联级别加载策略。 类级别加载策略比
hibernate _类级别加载策略
weixin_34242509的博客
01-31 138
一：数据表||实体类1、数据库表数据1、Orders表 2、Customer表 2、实体类1、Orders实体类2、Customer实例类二：load(延迟加载) || get(普通加载)1、使用get方法进行查询1、openSession.get()加载时立即查询则会打印SQL语句2、使用load方法加载1、(默认)是执行时,不发生SQL语句,返回一个对象,使用该对象时才执行SQL查询 2、延...
hibernate _关联级别策略介绍
weixin_34233679的博客
01-31 179
一：数据表||实体类1、数据库表数据1、Orders表 2、Customer表 2、实体类1、Orders实体类2、Customer实例类二：关联级别1、集合关联策略1-0、加载的策略1-1、lazy="true" &amp;&amp; fetch="select"(默认情况)1、执行44行时&lt;不执行查询集合&gt; 2、执行47行使用时&lt;才加载集合数据&gt; 1-2、lazy="f...
Hibernate中类级别和关联级别加载策略
hongcaixia的博客
01-23 2231
抓取策略（优化） 1.检索方式 立即检索：立即查询，在执行查询语句时，立即查询所有的数据。 延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载） 2.检查策略 类级别检索：当前的类的属性获取是否需要延迟。 关联级别的检索：当前类 关联 另一个类是否需要延迟。 3.类级别检索 get：立即检索。get方法一执行，立即查询所有字段的数据。 loa...
SSH与SSM学习之hibernate23——关联级别加载策略之集合关联加载策略
qiwenmingshiwo的专栏
09-22 269
SSH与SSM学习之hibernate23关联级别加载策略之集合关联加载策略 一说明 二lazy和fetch的取值 true false extra select selecttrue selectfalse join jointure joinfalse subselect subselecttrue subselecttrue三配置文件 Company
Hibernate中的多表查询及抓取策略
08-31
延迟加载分为类级别和关联级别。 - **类级别的延迟加载**：在`session.load()`方法中，默认为延迟加载。如果类被声明为`final`或在映射文件中设置`lazy="false"`，则延迟加载会失效。 - **关联级别的延迟加载**...
JAVA学习资料-Hibernate简介.doc
06-10
在Web层，Hibernate支持延迟加载，这意味着关联对象只有在真正需要时才会从数据库加载，以提高效率。例如，当实体的一个集合属性未在查询时明确加载时，会等到首次访问该属性时才加载数据。 总之，Hibernate为Java...
Manning - Hibernate in action
08-11
12. **性能优化**：包括批处理、缓存利用、连接池管理、懒加载策略调整等，以提高应用性能。 13. **Hibernate与其他技术集成**：如Spring Framework的整合，利用AOP实现声明式事务管理，以及与JSF、Struts等Web框架...
39-Hibernate数据关联实现〖MVSN〗_Struts + DAO + Hibernate(2).
01-13
8. **懒加载和即时加载**：Hibernate支持懒加载和即时加载策略，用于优化对象的加载时机。懒加载只在真正需要数据时才加载关联的对象，而即时加载则会在加载主对象时同时加载关联对象。 9. **事务管理**：在数据库...
Hibernate延迟加载介绍.doc
10-09
Hibernate作为Java领域中的一个强大的对象关系映射框架，提供了许多优化数据库操作的策略，其中之一便是延迟加载（Lazy Loading）。延迟加载机制旨在减少不必要的性能消耗，只在真正需要数据时才执行加载操作。本文...
hibernate关联级别策略
qq_36730954的博客
05-12 227
1.数据表和实体 实体关系：客户和联系人之间是一对多的关系 主表：cst_customer，客户的cust_id作为联系人的外键 从表：cst_linkman，一个客户可以对应多个联系人 Customer对象中有linkMens集合 LinkMan对象中有customer对象 2.关联级别策略 有两种：集合关联策略、属性关联策略 集合策略：在Customer.hbm.xml中配置 fetch属性：决定加载策略：使用什么类型的sql语句加载集合数据 select：默认值，单表查询加载
4.4.6 在映射中选择加载策略
oneGeng的专栏
05-25 686
 Hibernate允许在元数据中指定默认的关联加载策略。你可以通过重写Hibernate查询方法来修改默认的策略。这里有个小建议：你不需要立即理解所有的选项；我们建议先整体浏览这部分的内容，在以后的程序可以作为参考。在Hibernate的映射中，集合的映射和普通对象的映射有不同的地方，所以，将分别来讨论这两种情况。首先来考虑Bid和Item之间的双向关联。单点关联对于或者关联来说
hibernate抓取策略（关联级别的延迟加载）
东方
12-20 368
1.3Hibernate的抓取策略（优化） 延迟加载的概述 通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。 通过或者在上通过fetch属性进行设置 fetch和这些标签上的lazy如何设置优化发送的SQL语句 1.3.1.1什么是延迟加载 延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的...
加载策略 抓取策略
仅做个人笔记
02-23 382
https://www.cnblogs.com/fingerboy/p/5256087.html 加载策略 假设现在有Book和Category两张表,表的关系为双向的一对多,表结构如下: 假设现在我想查询id为2的那本书的书名,使用session.get(...)方法: 1 Session session=HibernateUtil.getSession(); 2 Book boo...
Hibernate检索策略(类级别，关联级别，批量检索)详解
qq_39665334的博客
10-06 295
  一、概述 检索策略分三大块，类级别检索策略和关联级别检测策略。 　　　　　　　　类级别检索策略：get、load、 　　　　　　　　关联级别检索策略：order.getCustomer().getName() 　　　　　　　　上面这两种应该是看得懂的。很容易去理解，现在就具体来说说这两种其中的细节。 　　　　批量检索解决n+1问题。 二、类级别检索策略 1.立即检索get 　...
Hibernate深入学习(四）：类级别的检索策略
我要做的就是比昨天的我更强
06-23 505
hibernate提供了懒加载的检索策略，在没有用到类的相关属性时，不会发出sql从数据库中检索，而懒加载分为两种：类级别的懒加载和集合的懒加载，本章先来看看类级别的懒加载检索策略以下是测试用的实体类：Parent，Children，他们是双向一对多的关系，类的具体属性如下：//省略getter和setter，为了方便测试，请重写toString() public class Parent {
hibernate☞FetchType关联关系的加载策略
Sucre
08-05 2263
hibernate的对关联关系有两种加载方式：Lazy懒加载，Eager急加载 懒加载：即在用到的时候进行加载； 急加载：在实体加载的同时就对该属性进行加载； 1. 懒加载的配置 @ManyToMany(fetch = FetchType.LAZY) private List friends; 2. 急加载的配置 @ManyToMany(fetch = FetchT
基于STM32控制遥控车的蓝牙应用程序
最新发布
06-27
基于STM32控制遥控车的蓝牙应用程序

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值