Hibernate学习----检索策略

最新推荐文章于 2022-03-13 14:22:03 发布
最新推荐文章于 2022-03-13 14:22:03 发布
阅读量142 收藏
点赞数
分类专栏： java WebFrame learning 文章标签： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21467113/article/details/91347322
版权
learning 同时被 3 个专栏收录
90 篇文章 2 订阅
订阅专栏
java
73 篇文章 0 订阅
订阅专栏
WebFrame
52 篇文章 0 订阅
订阅专栏

检索策略

       1.检索(查询)方式:

  • 立即检索：当查询数据，马上执行查询select语句
  • 延迟检索：当执行查询，但只到需要时再查询。
    优化：减少当时对数据库访问压力。
    hibernate实现，必须使用代理类进行增强。

        2.检索策略

  • 类级别：查询当前对象，除了OID，其他的字段是否延迟。
  • 关联级联：查询当前前对象，需要获得关联对象时，是否进行延迟。

        3.查询方法，类级别

  • get() 类级别，立即检索。如果查询数据不存在，将返回null
  • load() 类级别，默认延迟检索。如果查询数据不存在，将抛异常
  • hbm.xml  <class name="" table="" lazy="">
            true: 默认值，延迟检索
            false:立即检索

       4.关联级别：

              一对多或 多对多： 多方存在容器(集合Set)

  •               <set lazy="" fetch="">
                         lazy: false/true/extra
                                  lazy="false" 所有select立即查询。
                                  lazy="true" 与关联对象select 只有当需要是才查询。
                                  lazy="extra" 极其懒惰，如果可以使用聚合函数完成功能，就不进行详细查询。
                         fetch: join/select/subselect
                                  fetch="join" 底层使用迫切左外连接，只执行一个select语句，底层使用左外连接。
                                  fetch="select" 默认，将执行多条select语句
                                  fetch="subselect" 将执行子查询，注意：需要使用Query查询

检索策略：多对一或一对一

            1.介绍：<many-to-one fetch="" lazy="">

  •        fetch取值：join、select
                       fetch="join" ，将采用迫切左外连接，lazy无效。  将采用一条select，查询所有需要的数据。
                       fetch="select" 将执行多条select语句
  •        lazy取值：false、proxy、no-proxy
                      lazy="false"立即，当查询订单，同时再查询客户，使用多条select语句
                      lazy="proxy" 订单使用客户的数据，客户何时初始化，取决客户的类级别检索策略。
                      lazy="no-proxy" 不研究
Customer.hbm.xml
<class name="cn.itcc...Customer" lazy="true"> 延迟
<class name="cn.itcc...Customer" lazy="false"> 立即

             2.示例：

①修改Order.hbm.xml

<!-- 多对一：多个订单 属于 一个客户 -->
<many-to-one name="customer" class="Customer" column="customer_id" fetch="join" ></many-to-one>

②api操作

@Test
	public void demo03() {
		// 查询订单，如何初始化客户数据
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 查询订单
		Order order = (Order) session.get(Order.class, 1);
		//2 获得客户
		Customer customer = order.getCustomer();
		System.out.println(customer.getCname());
		session.getTransaction().commit();
		session.close();
	}

检索(查询)方式总结

HQL：hibernate查询语句，类似与sql语句

QBC： query by criteria hibernate提供纯面向对象查询语句，没有任何sql影子。

              1.查询所有

@Test
	public void demo01(){
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL ,使用对象
		List<Customer> allCustomer = session.createQuery("from Customer").list();		
		//2 sql，使用表 ,通过addEntity设置如何封装数据
		//List<Customer> allCustomer = session.createSQLQuery("select * from t_customer").addEntity(Customer.class).list(); 		
		//3 QBC 
		//List<Customer> allCustomer = session.createCriteria(Customer.class).list();		
		//打印
		for (Customer customer : allCustomer) {
			System.out.println(customer);
		}
		session.getTransaction().commit();
		session.close();
	}

             2.固定值条件查询

@Test
	public void demo02(){
		//固定条件值查询
		// * uniqueResult()将查询唯一结果，如果没有返回null，如果结果大于1将抛异常。
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL 
		Customer customer = (Customer) session.createQuery("from Customer c where c.cname = 'rose' ").uniqueResult();		
		//2 sql
		//Customer customer = (Customer) session.createSQLQuery("select * from t_customer where cname='rose'").addEntity(Customer.class).uniqueResult();		
		//3 QBC
		/*
		Customer customer = (Customer) session.createCriteria(Customer.class)
						.add(Restrictions.eq("cname", "rose"))
						.uniqueResult();
		 */		
		//打印
		System.out.println(customer);
		session.getTransaction().commit();
		session.close();
	}

              3.排序 

@Test
	public void demo03(){
		//排序 ,mysql语法 ：  select ... order by 字段名 asc|desc
		// * asc :升序 ， desc:降序
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL ,使用对象
		List<Customer> allCustomer = session.createQuery("from Customer c order by c.cid desc").list();		
		//2 sql，使用表 ,通过addEntity设置如何封装数据
		//List<Customer> allCustomer = session.createSQLQuery("select * from t_customer c order by c.cid desc").addEntity(Customer.class).list(); 		
		//3 QBC , hibernate 提供Order对象进行排序， desc(属性名称)方法降序， asc(属性名称)方法升序
		/*
		List<Customer> allCustomer = session.createCriteria(Customer.class)
				.addOrder(org.hibernate.criterion.Order.desc("cid"))
				.list();
		 */		
		//打印
		for (Customer customer : allCustomer) {
			System.out.println(customer);
		}
		session.getTransaction().commit();
		session.close();
	}

              4.分页 

@Test
	public void demo04(){
		//分页，mysql格式： select ... limit 开始索引,每页显示个数
		// hibernate分页，提供 setFirstResult() 设置开始索引， setMaxResults() 设置每页显示个数
		Session session = factory.openSession();
		session.beginTransaction();				
		//1 HQL ,使用对象
		List<Customer> allCustomer = session.createQuery("from Customer")
				.setFirstResult(0)
				.setMaxResults(2)
				.list();
		//2 sql，使用表 ,通过addEntity设置如何封装数据
		/*
		List<Customer> allCustomer = session.createSQLQuery("select * from t_customer")
				.addEntity(Customer.class)
				.setFirstResult(0)
				.setMaxResults(2)
				.list(); 
		 */		
		//3 QBC 
		/*
		List<Customer> allCustomer = session.createCriteria(Customer.class)
				.setFirstResult(0)
				.setMaxResults(2)
				.list();
		 */		
		//打印
		for (Customer customer : allCustomer) {
			System.out.println(customer);
		}
		session.getTransaction().commit();
		session.close();
	}

              5.绑定参数 

@Test
	public void demo05(){
		/* 绑定参数
		 * 	方式1：占位符? ,使用?替换实际参数
		 * 		setXxx(int,Object) ， 第一参数int，表示?索引号，从0开始。
		 * 		例如：setString(0,"rose")
		 *  方式2：别名格式  	“:名称”
		 *  	setXxx(String,Object) ，第一个参数String，表示之前进行命名
		 *  	例如：setString("别名","rose")
		 */
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL 
		Customer customer = (Customer) session.createQuery("from Customer c where c.cname = ? ").setString(0, "rose").uniqueResult();
//		Customer customer = (Customer) session.createQuery("from Customer c where c.cname = :xxx ").setString("xxx", "rose").uniqueResult();		
		//2 sql
		/*
		Customer customer = (Customer) session.createSQLQuery("select * from t_customer where cname=?")
				.addEntity(Customer.class)
				.setString(0, "rose")
				.uniqueResult();
		 */		
		//3 QBC 不变
		/*
		Customer customer = (Customer) session.createCriteria(Customer.class)
						.add(Restrictions.eq("cname", "rose"))
						.uniqueResult();
		 */		
		//打印
		System.out.println(customer);
		session.getTransaction().commit();
		session.close();
	}

                 6.聚合函数

@Test
	public void demo06(){
		/* 聚合函数
		 */
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL  count(*) , count(c)
		Object obj = session.createQuery("select count(c) from Customer c").uniqueResult();		
		//2 sql
		//Object obj = session.createSQLQuery("select count(*) from t_customer").uniqueResult();		
		//3 QBC 不变
		/*
		Object obj = session.createCriteria(Customer.class)
				.setProjection(Projections.projectionList().add(Projections.rowCount()))
				.uniqueResult();
		 */		
		//打印
		System.out.println(obj);
		session.getTransaction().commit();
		session.close();
	}

                7.分组 

@Test
	public void demo07(){
		/* 分组
		 */
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL  count(*) , count(c)
		Object obj = session.createQuery("select c.cname from Customer c group by c.cname").list();		
		//2 sql
		//Object obj = session.createSQLQuery("select c.cname from t_customer c group by c.cname").list();		
		//3 QBC 不变
		/*
		Object obj = session.createCriteria(Customer.class)				.setProjection(Projections.projectionList().add(Projections.groupProperty("cname")))
				.list();
		 */		
		//打印
		System.out.println(obj);
		session.getTransaction().commit();
		session.close();
	}

               8.投影 

@Test
	public void demo08(){
		//查询部分数据：投影查询
		Session session = factory.openSession();
		session.beginTransaction();		
		//1 HQL , 默认情况，如果查询一列，将封装Object，如果查询多列，将封装Object[]
		// * 可以通过构造方法进行对象创建，从而将数据封装到指定对象中,例如：new Customer(cname) 
		List<Customer> allCustomer = session.createQuery("select new Customer(cname) from Customer").list();		
		//2 sql，使用表 ,通过addEntity设置如何封装数据
		// * 设置结果集转换，按照查询别名和对象属性对应赋值
		/*
		List<Customer> allCustomer = session.createSQLQuery("select cname from t_customer")
				.setResultTransformer(new AliasToBeanResultTransformer(Customer.class))  
				.list(); 
		*/
		//3 QBC 
		/* Projections.projectionList() 设置查询的列表 ， select ... from
		 * Projections.alias() 设置别名
		 * Projections.property("cname") 确定使用属性
		List<Customer> allCustomer = session.createCriteria(Customer.class)				.setProjection(Projections.projectionList().add(Projections.alias(Projections.property("cname"), "cname")))
				.setResultTransformer(new AliasToBeanResultTransformer(Customer.class))  
				.list();
		 */		
		//打印
		for (Customer customer : allCustomer) {
			System.out.println(customer);
		}
		session.getTransaction().commit();
		session.close();
	}

命名查询

  1. 将hql语句存放配置文件
  2. 之后通过session.getNamedQuery("名称")
  •        getNamedQuery("名称")        <hibernate-mapping><query name="名称">
  •        getNamedQuery("类全路径.名称") <hibernate-mapping><class name="类全路径"><query name="名称">

   @Test
   public void demo10(){
      //命名查询：将hql或sql语句，存放配置文件中，之后通过给语句起一个名称，在代码通过名称执行
      Session session = factory.openSession();
      session.beginTransaction();    
      //1 HQL
      List<Customer> allCustomer = session.getNamedQuery("findAllCustomer").list();
      //打印
      for (Customer customer : allCustomer) {
          System.out.println(customer + ", 订单数： " + customer.getOrderSet().size());
      }
      session.getTransaction().commit();
      session.close();
   }

 

 

 

 

 

 

 

            

 

 

没有刺的仙人掌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate -annotation 学习笔记
06-25
通过这些课程，你可以系统地学习Hibernate Annotation，逐步掌握如何在实际项目中使用它来实现高效、灵活的数据存储和检索。在实践中不断探索和实践，将有助于你成为一名精通Hibernate的开发者。
hibernate-jpa学习
08-13
**标题：“Hibernate-JPA学习”** 在Java世界中，Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者以面向对象的方式处理数据库操作。而Java Persistence API (JPA) 是Java EE平台中的一个规范，它定义...
Hibernate学习---检索优化
MindMrWang的blog
11-24 247
Hibernate框架对检索进行了优化，前面我们将CURD的时候提到了load和get的区别，当时仅仅说了load为延迟加载，get为立即加载，当检索的记录为空的时候load报错（不是在执行load方法的时候报的错，是执行后面的操作报的错），get返回null。 其实load就是对检索的一种优化，它的作用是当程序执行检索代码的时候，在缓存中没有的前提下，不会立即去数据库中查询，而是等真正用到的时候
hibernate学习---检索优化
m0_37109682的博客
10-11 105
&#13; Hibernate框架对检索进行了优化，前面我们将CURD的时候提到了load和get的区别，当时仅仅说了load为延迟加载，get为立即加载，当检索的记录为空的时候load报错（不是在执行load方法的时候报的错，是执行后面的操作报的错），get返回null。  其实load就是对检索的一种优化，它的作用是当程序执行检索代码的时候，在缓存中没有的前提下，不会立即...
Hibernate----学习（17）----检索策略
lsh15846393847的博客
03-14 160
1.类级别的检索策略 1.1 类级别可选的检索策略包括立即检索和延迟检索, 默认为延迟检索 –立即检索: 立即加载检索方法指定的对象 –延迟检索: 延迟加载检索方法指定的对象。在使用具体的属性时，再进行加载 1.2 类级别的检索策略可以通过 <class> 元素的 lazy 属性进行设置 ...
Hibernate学习笔记----检索策略
太匆匆
07-24 299
Customer.java package cn.limbo.hibernate.strategy; import java.util.HashSet; import java.util.Set; public class Customer { private Integer customerId; private String customerName; private Se
Hibernate 检索策略的学习
5big的博客
01-17 286
检索数据也就是查询数据的时候存在两个问题： 1.不浪费内存：例如，Customer和Order是双向1-N的关系。当 Hibernate 从数据库中加载 Customer 对象时， 如果同时加载所有关联的 Order 对象， 而程序实际上仅仅需要访问 Customer 对象， 那么这些关联的 Order 对象就白白浪费了许多内存。 2.更高的查询效率：发送尽可能少的 SQL 语句。 延伸：S
Hibernate--初级
张常文的博客
02-09 295
2017.2.6-2017.2.9javaee三层结构 web层：struts2框架 service层：Spring框架 dao层：hibernate框架对数据库进行CURD 什么是hibernate框架 hibernate框架应用于Javaee三层结构中的dao层框架 在dao层里面做对数据库crud操作，使用hibernate实现crud操作，hibernate底层代码就是jdbc，hibern
Hibernate学习笔记 -- day11 Hibernate中的检索策略
wingzhezhe的博客
07-28 258
一
hibernate学习之检索策略
淘技术
06-21 220
检索策略的概念 1.hibernate检索测策略分为两种 （1）立即查询：根据id查询，调用get方法，一调用就发送sql语句查询数据库数据 Session session = SessionFactoryUtil.GetSession(); Customer c = session.get(Customer.class, "4028802d5cc56d3b015cc56d3dc
Hibernate入门篇 - ORM真香
非真非假，非零非一
10-06 468
文章目录Hibernate ORMHibernate架构配置对象SessionFactory对象Session对象Transaction对象Query对象Criteria引入Hibernate手动引入mavenhibernate.cfg.xml配置文件几个重要的配置属性数据库方言简单的XML映射文件hibernate type预设值原始类型日期和时间类型二进制和大型数据类型JDK相关类型映射注解@Entity@Table@Id@GeneratedValue@Column@DynamicUpdate和@Dyn
hibernate-3.2 源码
11-18
在Hibernate-3.2中，配置文件通常为`hibernate.cfg.xml`，包含了数据库连接信息、实体类映射、缓存策略等设置。通过`Configuration`类加载配置，然后构建SessionFactory。 三、实体类与映射文件 Hibernate通过ORM...
hibernate-9-10
03-20
1. 改进的性能：新版本对查询优化进行了改进，包括更智能的缓存策略和查询编译，从而提高了运行时效率。 2. 更强的JPA支持：Hibernate 9-10进一步兼容Java Persistence API（JPA），提供了更多的JPA 2.x特性和扩展...
yealico站点规则编写手册（基础）
nonpricklycactus的博客
03-13 2万+
yealico站点规则编写的简单介绍，主要给一些会前端的同学的引导，能尽快的上手，如果你对于前端一窍不通，还是去找别人分享的规则去
常用设计模式Python实现
nonpricklycactus的博客
04-24 6533
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 代码查看：https://github.com/nonpricklycactus/Design-Pattern 一、设计模式分类 经典的《设计模式》一书归纳出23种设计模式，这23种模式又可...
SpringBoot注解详解-----@RequestMapping详解
nonpricklycactus的博客
08-14 3763
@RequestMapping详解 RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。 RequestMapping注解有六个属性： value， method； value： 指定请求的实际地址，指定的地址可以是URI Template 模式（...
scrapy中 yield使用详解
nonpricklycactus的博客
07-21 3443
import scrapy from text_info.items import TextInfoItem class A50zwSpider(scrapy.Spider): name = '50zw' allowed_domains = ['m.50zw.la'] start_urls = ['http://m.50zw.la/wapsort/1_1.html'] ...
算法初级----算法的基本原理
nonpricklycactus的博客
05-03 1192
何为算法？ 算法直白的说就是如果你给我一个数据源，在这个源的结构（即数据结构）上完成的一系列操作。 当通过两种算法解决同一问题，如何比较两个算法的优劣？ 时间复杂度：一个算法流程中，常数操作数量的指标，这个指标叫做O，bigO。 空间复杂度：一般提空间复杂度指的是额外空间复杂度，指我给你的输入，输出不算在额外空间里。为了支持你的流程你需要使用多少辅助空间才能完成的那些空间叫...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值