Hibernate学习笔记（六）加载策略

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量126 收藏
点赞数
分类专栏： Hibernate 文章标签： java hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41816516/article/details/105853960
版权

加载策略（优化查询）

  1. 策略种类：
    • 延迟加载：等到使用的时候才会加载
    • 立即加载：不管使不使用，都会立即将数据加载
  2. 策略的应用：
    • 类级别的加载策略：
      • get/load方法
        • get：立即查询数据库，将数据初始化
        • load：hbm文件中class元素的lazy属性中对类级别的load方法的加载策略
          • true：先返回一个代理对象，使用代理对象的属性时，才会去查询数据库。
          • false：与get方法一致，会立即加载数据
    • 关联级别的加载策略：在查询有关联关系的数据时，加载一方是否需要将另一方立即查询出。
      • 默认：与我关联的数据，在使用时才会加载
      • 集合：
        • 在set元素中lazy属性：是否对set元素的数据采用懒加载
          • true：对集合使用懒加载（默认）
          • false：集合将会立即加载
          • extra：及其懒惰，如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
        • 在set元素中fetch属性：决定加载集合使用的sql语句种类
          • select：（默认值）普通select查询
          • join：使用表连接语句查询集合数据
          • subselect：使用子查询加载集合数据
fetchlazy结论
selecttrue默认值, 会在使用集合时加载,普通select语句
selectfalse立刻使用select语句加载集合数据
selectextra会在使用集合时加载,普通select语句,如果只是获得集合的长度,会发送Count语句查询长度.
jointrue查询集合时使用表链接查询,会立刻加载集合数据
joinfalse查询集合时使用表链接查询,会立刻加载集合数据
joinextra查询集合时使用表链接查询,会立刻加载集合数据
subselecttrue会在使用集合时加载,子查询语句
subselectfalse会在查询用户时,立即使用子查询加载客户的订单数据
subselectextra会在使用集合时加载,子查询语句,如果只是获得集合的长度,会发送Count语句查询长度.
public class Demo2 {
	@Test
	//关联级别懒加载
	//默认: 与我关联的数据,在使用时才会加载.
	public void fun1(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Customer c = (Customer) session.get(Customer.class, 1);
		

		for(Order o : c.getOrders()){
			System.out.println(o.getName());
		}
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	
	@Test
	//关联级别懒加载
	//lazy: false
	public void fun2(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Customer c = (Customer) session.get(Customer.class, 1);
		

		for(Order o : c.getOrders()){
			System.out.println(o.getName());
		}
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//关联级别懒加载
	//lazy: false/true
	//fetch:join
	public void fun3(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Customer c = (Customer) session.get(Customer.class, 1);
		

		for(Order o : c.getOrders()){
			System.out.println(o.getName());
		}
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//关联级别懒加载
	//lazy:true
	//fetch:subselect
	public void fun4(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
			List<Customer> list = session.createQuery("from Customer").list();
			
			for(Customer c:list){
				System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
			}
			
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//关联级别懒加载
	//lazy:false
	//fetch:subselect
	public void fun5(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
			List<Customer> list = session.createQuery("from Customer").list();
			
			for(Customer c:list){
				System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
			}
			
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//关联级别懒加载
	//lazy:extra
	//fetch:select
	public void fun6(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		//查询Customer
		Customer c = (Customer) session.get(Customer.class, 1);
		//查询Customer下订单 数量
		System.out.println(c.getOrders().size());

		//真正使用订单中的数据
		for(Order o : c.getOrders()){
			System.out.println(o.getName());
		}
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@SuppressWarnings("unchecked")
	@Test
	//关联级别懒加载
	//lazy:extra
	//fetch:subselect
	public void fun7(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
			List<Customer> list = session.createQuery("from Customer").list();
			
			for(Customer c:list){
				System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
			}
			
			for(Customer c:list){
				for(Order o : c.getOrders()){
					System.out.println(c.getName()+"下单名称:"+o.getName());
					
				}
			}
			
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
}
  1. 多对一加载策略
    • lazy：many-to-one元素中的lazy属性：
      • false：加载订单时,会立即加载客户
      • proxy ：看客户对象的类加载策略来决定
      • no-proxy ：不做研究.
    • fetch：
      • select : (默认值)使用普通select加载
      • join : 使用表链接加载数据
fetchlazy结果
selectfalse加载订单时,立即加载客户数据.普通select语句加载客户.
selectproxyclass元素：lazy=false ：同上
selectproxyclass元素：lazy=true：加载订单时,先不加载客户数据.使用客户数据时才加载
joinfalse使用表链接查询订单以及对应客户信息.lazy属性无效
joinproxy使用表链接查询订单以及对应客户信息.proxy属性无效
//多对一检索策略
public class Demo3 {
	@Test
	//fetch: select
	//lazy: false
	public void fun1(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	
	@Test
	//fetch: select
	//lazy: proxy
	// Customer lazy:false
	public void fun2(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	@Test
	//fetch: select
	//lazy: proxy
	// Customer lazy:true
	public void fun3(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//fetch: join
	//lazy: proxy|false
	public void fun4(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
}
  1. 批量加载
    • 当客户关联查询订单，给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。
    • set元素：
      • batch-size：决定一次加载几个对象的集合数据. in 条件加载多个用户的订单.
//批量策略
public class Demo4 {
	@SuppressWarnings("unchecked")
	@Test
	//查询所有客户
	//遍历客户,打印客户下的订单信息
	public void fun1(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		List<Customer> list = session.createQuery("from Customer").list();
		
		for(Customer c:list){
			System.out.println(c.getOrders().size());
		}
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	
	@Test
	//fetch: select
	//lazy: proxy
	// Customer lazy:false
	public void fun2(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	@Test
	//fetch: select
	//lazy: proxy
	// Customer lazy:true
	public void fun3(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
	
	@Test
	//fetch: join
	//lazy: proxy|false
	public void fun4(){
		Session session = HibernateUtils.openSession();
		session.beginTransaction();
		//------------------------------------------------
		Order o = (Order) session.get(Order.class, 2);
		
		System.out.println(o.getCustomer().getName());
		
		//------------------------------------------------
		session.getTransaction().commit();
		session.close(); // 游离状态
	}
}

总结

果然框架就是为了提高效率的，更加便捷的为人服务的。

程序胖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate 学习笔记&代码.zip
01-15
本学习笔记和代码资源是基于黑马程序员在 B 站上的《Hibernate框架》课程，该课程深入浅出地讲解了 Hibernate 的核心概念和实际应用。 **第一天：Hibernate 概述与环境搭建** 1. **Hibernate 概念**：Hibernate 是...
传智播客2016hibernate框架学习笔记
03-11
《传智播客2016 Hibernate框架学习笔记》是一份详实的教程，旨在帮助初学者和进阶者深入理解和掌握Hibernate框架。该资源包含了四天的学习内容，分别是day01、day02、day03和day04，涵盖了从基础到高级的多个主题。...
hibernate的加载策略
oydl_1234的博客
10-27 467
hibernate是通过管理对象来操作数据的。这里对象值得是持久性对象。 对象的三种状态： 临时状态  持久状态 游离状态   这三种状态的对象是可以相互转换的，通过编码时只关注持久化对象。也就是get/save/update方法所操作后的对象。   一级缓存 作用：提高CPU的运行效率 一级缓存越大，CPU的运行效率越高，但受到CPU内部结构的限制，一级缓存的容量都很小。...
MyBatis加载策略
亦翼的博客
07-04 197
文章目录MyBatis加载策略延迟加载的概念延迟加载的具体实现局部延迟加载设置触发延迟加载的方法全局延迟加载 MyBatis加载策略 延迟加载的概念 在需要用到数据时才进行加载，不需要用到数据时就不进行加载。延迟加载又称懒加载，基于嵌套查询来实现。 优点： 先从单表查询，需要时再从关联表去关联查询，因为查询单表要比关联查询多张表速度要快，可以大大提高数据库性能。 缺点： 因为只有当需要用到数据时，才会进行数据库查询，这样在大批量查询数据时，可能会造成用户等待时间变长，用户体验下降。 建议：
加载策略 抓取策略
仅做个人笔记
02-23 384
https://www.cnblogs.com/fingerboy/p/5256087.html 加载策略 假设现在有Book和Category两张表,表的关系为双向的一对多,表结构如下: 假设现在我想查询id为2的那本书的书名,使用session.get(...)方法: 1 Session session=HibernateUtil.getSession(); 2 Book boo...
Hibernate 加载策略
zys_1997的博客
09-11 850
Hibernate 加载策略
Hibernate加载策略
zpl_118的博客
10-25 137
对象的三种状态（hibernate管理的对象） 1.1 临时状态 1.2 持久状态 1.3 游离状态 hibernate通过管理对象来操作数据库，这里对象指的是持久态的对象。 各种状态的对象是可以相互转换。 2.一级缓存、快照（orm特性） Transaction transaction = session.beginTransaction(); User user = ses...
邹波老师Hibernate教程学习笔记
11-10
8. **懒加载与立即加载**：Hibernate提供了懒加载和立即加载策略来控制关联对象的加载时机，以提高性能。笔记会探讨何时选择哪种策略。 9. **级联操作**：在处理关联对象时，级联操作允许一次操作影响到多个关联的...
Hibernate学习笔记
02-14
【Hibernate学习笔记】 在深入探讨Hibernate之前，先要理解什么是持久化对象的状态。持久化对象在Hibernate中有三种状态：瞬时（Transient）、持久化（Persistent）和离线（Detached）。瞬时对象是指通过`new`操作...
性能优化系列之『页面加载：加载策略都有哪些？又该如何选型？』
老__L的博客
01-04 681
懒加载也叫延迟加载，指的是长网页中延迟加载特定元素（可以是图片，也可以是 JS/CSS 文件，当然也可以是 JavaScript 的特定函数和方法，以下简称“懒加载元素”）。可以使用预加载让浏览器来预先加载某些资源（比如图片、JS/CSS/模板），而这些资源是在将来才会被使用到的。简单来说，就是将所需资源提前加载到浏览器本地，这样后面在需要使用的时候就可以直接从浏览器缓存中取了，而不用再重新开始加载。楼层数据异步加载和本地缓存相结合的方式
任务三：加载策略及注解开发
m0_63640914的博客
08-10 335
mybatis注解开发
Java：63-Mybatis加载策略
qq_59609098的博客
04-15 1013
*在一对多中，当我们有一个用户，它有个100个订单在查询用户的时候，要不要把关联的订单查出来？在查询订单的时候，要不要把关联的用户查出来？回答在查询用户时，用户下的订单应该是，什么时候用，什么时候查询在查询订单时，订单所属的用户信息应该是随着订单一起查询出来*/--开启全局延迟加载功能，那么就不用添加fetchType="lazy"来启动延迟加载了--> < setting name = " lazyLoadingEnabled " value = " true " />
Hibernate中类级别和关联级别加载策略
hongcaixia的博客
01-23 2237
抓取策略（优化） 1.检索方式 立即检索：立即查询，在执行查询语句时，立即查询所有的数据。 延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载） 2.检查策略 类级别检索：当前的类的属性获取是否需要延迟。 关联级别的检索：当前类 关联 另一个类是否需要延迟。 3.类级别检索 get：立即检索。get方法一执行，立即查询所有字段的数据。 loa...
ETL加载策略
weixin_33709364的博客
09-12 1159
2019独角兽企业重金招聘Python工程师标准>>> ...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
weixin_70987470的博客
07-20 345
从本地导入Junit
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 953
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
马士兵教程：Hibernate学习笔记与Annotation实践
"马士兵hibernate学习笔记(原版)，涵盖了Hibernate的基础到进阶知识，包括原理、配置、对象状态、关系映射、查询优化等内容，适合初学者和进阶者学习。" Hibernate是一个开放源代码的对象关系映射（ORM）框架，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值