首页 博客列表 精选博客 智能问答 chat-GPT 关于我
Hibernate的查询方式（大全）（检索方式）OID查询+ HQL检索 +QBC检索+SQL检索
发布日期：2021-06-29 15:01:44 浏览次数：3 分类：技术文章

本文共 16589 字，大约阅读时间需要 55 分钟。

在Hibernate当中提供了多种查询方式。Hibernate一共提供了五中查询方式。

准备工作
假设我们现在有两个对象
客户----联系人
在这里插入图片描述
配置Hibernate工具类

public class HibernateUtils {
   	public static final Configuration cfg;	public static final SessionFactory sf;	static {
   		cfg = new Configuration().configure();// 获取与数据库的链接的配置文件		sf = cfg.buildSessionFactory();//开启事务建立与数据库之间的链接	}	public static Session openSession() {
   		return sf.openSession();	}	public static Session getCurrentSession() {
   		return sf.getCurrentSession();	}}

Hibernate的查询方式

1、Hibernate的查询方式：OID查询

OID检索：HIbernate根据对象的OID（主键）进行检索。

A：使用GET方法

Customer代表客户的意思（封装的数据库当中表的对象）

Customer customer = session.get(Customer.class,1l);//OID 检索，通过ID查询对应的对象的数据
B：使用load方法
Customer customer = session.load(Customer.class,1l);//OID 检索，通过ID查询对应的对象的数据

2、Hibernate的查询方式：对象导航检索

对象导航检索：Hibernate根据一个已经查询到的对象，去获得其关联的对象的一种查询方式。

在Hibernate当中可以这样使用

LinkMan linkMan= session.load(LinkMan.class,1l);//OID 检索，通过ID查询对应的对象的数据Customer customer = linkMan.getCustomer();//获得到联系人关联的对象（包括客户）Customer customer = session.get(Customer.class,2l);//OID 检索，通过ID查询对应的对象的数据Set
   
     linkMans = customer.getLinkMans();//通过对象获取到集合

3、Hibernate的查询方式：HQL检索

在这里插入图片描述

HQL查询：Hibernate Query Language：Hibernate的查询语言，是一种面向对象的一种查询语言，语法类似SQL。
通过session.createQuery();
用于接收HQL进行的一种查询方式。

Hibernate环境搭建和配置另一篇文章

A、初始化一些数据

/* * HQL 的查询方式的测试类 */public class HibernateDemo1 {
   	@Test	// 初始化数据	public void demo01() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 创建一个客户		Customer customer = new Customer();		customer.setCust_name("李冰");		for (int i = 1; i <= 10; i++) {
   			LinkMan linkMan = new LinkMan();			linkMan.setLkm_name("小花" + i);			linkMan.setCustomer(customer);			customer.getLinkMans().add(linkMan);			session.save(linkMan);		}		session.save(customer);		transaction.commit();	}}

初始化三组联系人和客户

在这里插入图片描述
在这里插入图片描述
B、HQL的简单查询
（1）HQL的简单查询
两个对象相互包含的时候注意toString，最好不要写对象的集合，因为这是个死循环
在这里插入图片描述

@Test	// HQL的简单查询	public void demo02() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		//得到所有的客户		Query query = session.createQuery("from  Customer");		List
   
     list = query.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

注意SQL当中支持*号的写法：例如 ：select * from cst_customer,但是在HQL当中不支持 * 的写法。

Query query = session.createQuery("from * Customer");//是错误的写法，运行代码时会报错

在这里插入图片描述

在这里插入图片描述
也可以这样查询
（2.0）HQL别名查询

@Test	// 别名查询	public void demo03() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 得到所有的客户		//别名查询		Query query = session.createQuery("from Customer c");//c是Customer的别名		List
   
     list = query.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

（2.1）HQL别名查询

@Test	// 别名查询	public void demo03() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 得到所有的客户		//别名查询		Query query = session.createQuery("select c from Customer c");//c是Customer		List
   
     list = query.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

C：HQL的排序查询
(1)默认排序：升序排序

@Test	// 排序查询	public void demo04() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 得到所有的客户		// 排序查询		List
   
     list = session.createQuery("from Customer order by cust_id").list();// c是Customer		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

（2）设置降序排序

@Test	// 排序查询	public void demo04() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 得到所有的客户		// 降序查询		List
   
     list = session.createQuery("from Customer order by cust_id desc").list();// c是Customer		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

升序使用asc降序使用desc
D：HQL的条件查询
(一)按位置绑定：根据参数的位置进行绑定。
(1)一个条件

@Test	// 条件查询	public void demo05() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 条件查询		// 一、按位置绑定		Query query = session.createQuery("from Customer where cust_name = ?");// c是Customer		query.setParameter(0, "李冰");		List
   
     list = query.list();		// 二、按名称绑定		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

(2)多个条件（模糊查询）

@Test	// 条件查询	public void demo05() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 条件查询		// 一、按位置绑定		Query query = session.createQuery("from Customer where cust_source = ? and cust_name like  ?");		query.setParameter(0, "小广告");		query.setParameter(1, "李%");		List
   
     list = query.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

（二）按名称绑定匿名名称

@Test	// 条件查询	public void demo05() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 条件查询		// 二、按名称绑定		Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like  :bbb");		//设置参数		query.setParameter("aaa", "朋友推荐"); 		query.setParameter("bbb", "李%");		List
   
     list = query.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

E：HQL的投影查询
投影查询：指的是查询对象的某个或某些属性。
（1）单个属性投影查询

@Test	// 投影查询	public void demo06() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 投影查询,查询当中的一个属性		List list = session.createQuery("select c.cust_name from Customer c").list();		for (Object object : list) {
   			System.out.println(object);		}		transaction.commit();	}

在这里插入图片描述

（2）多个属性投影查询

@Test	// 投影查询	public void demo06() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 投影查询,查询当中的一个属性		List
   
     list = session.createQuery("select c.cust_name,c.cust_source from Customer c").list();		for (Object[] objects : list) {
   			System.out.println(Arrays.toString(objects));		}		transaction.commit();	}

在这里插入图片描述

（3）查询多个属性分装到对象当中投影查询
先对要查询的对象写入构造方法
在这里插入图片描述

@Test	// 投影查询	public void demo06() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 查询多个属性，分装到对象当中		List
   
     list = session.createQuery("select new Customer(cust_name,cust_source) from Customer").list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

F：HQL的分页查询

@Test	// 分页查询	public void demo07() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// 分页查询		Query query = session.createQuery("from LinkMan");		query.setFirstResult(0);		query.setFirstResult(10);		List
   
     list = query.list();		for (LinkMan linkMan : list) {
   			System.out.println(linkMan);		}		transaction.commit();	}

注意在LinkMan当中也要生成对应的toString 方法

在这里插入图片描述
在这里插入图片描述
G：HQL的分组统计查询
（1）分组查询

@Test	// 分组统计查询	public void demo08() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		//聚合函数的使用：聚合函数包括：count()，max(),min(),avg(),sum()		//代表唯一结果uniqueResult		Object object = session.createQuery("select count(*) from Customer").uniqueResult();		System.out.println(object);		transaction.commit();	}

在这里插入图片描述

（2）分组统计（按照客户的来源统计客户的个数）
SQL语句：SELECT cust_source,COUNT(*) FROM cst_customer GROUP BY cust_source;
在这里插入图片描述
转换HQL将字段变为属性，把表的地方变为对象

@Test	// 分组统计查询	public void demo08() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		List
   
     list = session.createQuery("select cust_source,count(*) from Customer group by cust_source").list();//代表唯一结果uniqueResult		for (Object[] objects : list) {
   			System.out.println(Arrays.toString(objects));		}		transaction.commit();	}

在这里插入图片描述

限定条件

SQL语句：SELECT cust_source,COUNT(*) FROM cst_customer GROUP BY cust_source HAVING count(*) >= 2;
在这里插入图片描述

@Test	// 分组统计查询	public void demo08() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		List
   
     list = session.createQuery("select cust_source,count(*) from Customer group by cust_source HAVING count(*) >= 2").list();//代表唯一结果uniqueResult		for (Object[] objects : list) {
   			System.out.println(Arrays.toString(objects));		}		transaction.commit();	}

在这里插入图片描述

在这里插入图片描述

总结聚合函数

聚合函数的使用：聚合函数包括：count()，max(),min(),avg(),sum()
聚合函数 count（），求数据表的行数

select count(*/字段名) from 数据表

聚合函数 max（），求某列的最大数值

select max(字段名）from 数据表

聚合函数min（）,求某列的最小值

select main(字段名） from 数据表

聚合函数sum（）,对数据表的某列进行求和操作

select sum(字段名) from 数据表

聚合函数avg()，对数据表的某列进行求平均值操作

select avg(字段名） from 数据表

聚合函数和分组一起使用

select count(*),group_concat(age) from students group by age;
F：HQL的多表查询
a、SQL当中的多表查询
连接查询

i、交叉连接：笛卡尔积

# A,B 代表两个表，，这种查询方式一般不用select * from A,B;

ii、内链接 ： inner join(inner可以省略) 内链接查到的是两个表的交

{
隐式内链接 ：

# A 和 B 是两个表  A.id和B.id 分别对应两个表的关联字段select * from A,B where A.id=B.id;

显示内链接 ：

# A 和 B 是两个表  A.id和B.id 分别对应两个表的关联字段select * from A inner join B on A.id = B.id;

}

iii、外链接 外链接查询到的是两个表的交集以及left 或right对应的数据
{
左外链接 ：left outer join(outer 可以省略)

select * from A left outer join B on A.id = B.id;

右外链接 : right outer join(outer 可以省略)

select * from A right outer join B on A.id = B.id;

}

b、HQL当中的多表查询
链接查询

交叉连接

内链接

显式内连接：封装成为数组
隐式内连接 from Customer c inner join c.linkMans：封装成为数组

@Test	// HQL多表的查询	public void demo09() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// SQL:SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON c.cust_id =		// l.lkm_cust_id;		// HQL的内连接：from Customer c inner join c.linkMans		Query createQuery = session.createQuery("from Customer c inner join c.linkMans");		List
   
     list = createQuery.list();		for (Object[] objects : list) {
   			System.out.println(Arrays.toString(objects));		}		transaction.commit();	}

在这里插入图片描述

迫切内连接：（会将当前表外键对应的另外一个表当中的的数据都分装当中当前表对应的对象当中）封装成为对象

@Test	// HQL多表的查询	public void demo09() {
   		Session session = HibernateUtils.getCurrentSession();//建立连接		Transaction transaction = session.beginTransaction();//开启事务		// SQL:SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON c.cust_id =		// l.lkm_cust_id;		// HQL:迫切内连接 其实就是在普通的内连接inner join后添加一个关键字叫fetch --> from Customer c inner join		// fetch c.linkMans		// fetch通知Hibernate，将另一个对象的数据封装到该对象当中，也就是前面的对象当中（将LinkMan当中的数据放到Customer当中）		List
   
     list = session.createQuery("from Customer c inner join fetch c.linkMans").list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

获取到的内容是将LinkMan当中的东西分装到了Customer当中，并且数据冗余

在这里插入图片描述
在这里插入图片描述
改进上述查询方式 关键词 DISTINCT 用于返回唯一不同的值。

SELECT DISTINCT 列名称 FROM 表名称
@Test	// HQL多表的查询	public void demo09() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction transaction = session.beginTransaction();		// SQL:SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON c.cust_id =		// l.lkm_cust_id;		// HQL:迫切内连接 其实就是在普通的内连接inner join后添加一个关键字叫fetch --> from Customer c inner join		// fetch c.linkMans		// fetch通知Hibernate，将另一个对象的数据封装到该对象当中，也就是前面的对象当中（将LinkMan当中的数据放到Customer当中）		List
   
     list = session.createQuery("select distinct c from Customer c inner join fetch c.linkMans").list();		for (Customer customer : list) {
   			System.out.println(customer);		}		transaction.commit();	}

在这里插入图片描述

在这里插入图片描述

外链接

左外连接：封装成数组
右外连接：封装成数组
迫切左外连接：封装成对象

4、Hibernate的查询方式：QBC检索

QBC查询：Query By Criteria，叫做条件查询。是一种更加面向对象化的查询方式。

Criteria是一种比hql更面向对象的查询方式

（1）简单查询

通过session或者Criteria对象

criteria对象获取集合

@Test	// 简单的查询	public void demo01() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		// 获得Criteria的对象		Criteria criteria = session.createCriteria(Customer.class);		List
   
     list = criteria.list();		for (Customer customer : list) {
   				System.out.println(customer);		}		tx.commit();	}

在这里插入图片描述

（2）排序查询 criteria.addOrder(Order.条件)添加排序

a、升序排序

@Test	public void demo02() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		Criteria criteria = session.createCriteria(Customer.class);		criteria.addOrder(Order.asc("cust_id"));//升序		List
   
     list = criteria.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();	}

在这里插入图片描述

b、降序排序

@Test	public void demo02() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		Criteria criteria = session.createCriteria(Customer.class);		criteria.addOrder(Order.desc("cust_id"));//降序		List
   
     list = criteria.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();	}

在这里插入图片描述

（3）分页查询
@Test	public void demo03() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		Criteria criteria = session.createCriteria(LinkMan.class);		criteria.setFirstResult(0);		criteria.setMaxResults(10);		List
   
     list = criteria.list();		for (LinkMan linkMan : list) {
   			System.out.println(linkMan);		}		tx.commit();	}

在这里插入图片描述

（4）条件查询 add(Restrictions…) 限定条件
@Test	// 条件查询	public void demo04() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		// 条件查询		Criteria criteria = session.createCriteria(Customer.class);		// 设置条件		//=    eq		//>    gt		//<    ge		//<    lt		//<=   le		//<>   ne		//like		//in		//and		//or		criteria.add(Restrictions.eq("cust_source", "小广告"));		List
   
     list = criteria.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();	}

在这里插入图片描述

多条件查询

@Test	// 多条件查询	public void demo04() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		// 条件查询		Criteria criteria = session.createCriteria(Customer.class);		// 设置条件		//=    eq		//>    gt		//<    ge		//<    lt		//<=   le		//<>   ne		criteria.add(Restrictions.eq("cust_source", "小广告"));		criteria.add(Restrictions.like("cust_name", "李%"));		List
   
     list = criteria.list();				for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();	}

在这里插入图片描述

（5）统计分组查询

setProjection 方法用于设置查询的投影列。

该方法与 Projections 类结合不仅可以实现简单的投影查询，而且可以实现数据的分组统计。

@Test	// 统计查询	public void demo05() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		//先获取到要查询对象（Customer）的criteria		Criteria criteria = session.createCriteria(Customer.class);		/*		 * add            :普通条件在where后面的条件		 * addOrder		    ： 排序		 * setProgect();  ：聚合函数和group by  having 		 */		criteria.setProjection(Projections.rowCount());		Long num = (Long) criteria.uniqueResult();		System.out.println(num);		//从数据库当中活动		tx.commit();	}

在这里插入图片描述

（6）离线条件查询（SSH）—DetachedCriteria

在这里插入图片描述

在Web层创建该对象
以下是简略步骤

DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);dc.add(Restrictions.eq())://设置条件service.query(dc);

然后将dc该对象传入到业务层（dao层）

dao.query(dc);

以上是离线的，然后要在dao层与数据库建立连接

//绑定sessioncriteria.list();

实际操作：（离线条件查询）

@Test	// 离线条件查询	public void demo06() {
   		//=============假设这里是Web层		DetachedCriteria criteria = DetachedCriteria.forClass(Customer.class);		//Restrictions限定		criteria.add(Restrictions.ilike("cust_name", "李%"));		//=============		//==================dao		Session session = HibernateUtils.getCurrentSession();//建立连接		Transaction tx = session.beginTransaction();//开启事务		Criteria executableCriteria = criteria.getExecutableCriteria(session);//获得一个可执行的criteria（标准）对象		List
   
     list = executableCriteria.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();//提交事务	}

在这里插入图片描述

5、Hibernate的查询方式：SQL检索

SQL查询：通过使用SQL语句进行查询。

（1）查询到的结果封装到数组当中

public class HibernateDemo03 {
   	@Test	// SQL 查询	public void demo01() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");		List
   
     list = sqlQuery.list();		for (Object[] lists : list) {
   			System.out.println(Arrays.toString(lists));		}		tx.commit();	}}

在这里插入图片描述

（2）查询到的结果封装到对象当中

public class HibernateDemo03 {
   	@Test	// SQL 查询	public void demo01() {
   		Session session = HibernateUtils.getCurrentSession();		Transaction tx = session.beginTransaction();		SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");		sqlQuery.addEntity(Customer.class);		List
   
     list = sqlQuery.list();		for (Customer customer : list) {
   			System.out.println(customer);		}		tx.commit();	}}

在这里插入图片描述

转载地址：https://code100.blog.csdn.net/article/details/106239903 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：Hibernate环境搭建
下一篇：Hibernate多对多的关系映射，详解（代码+图解）与应用 举个栗子，搞的清楚

发表评论

最新留言

感谢大佬
[***.8.128.20]2024年04月17日 22时49分34秒

关于作者

    喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！
-- 愿君每日到此一游！

推荐文章

基于JavaWeb的物流管理系统的设计与实现 2019-04-29
基于Java的飞机大战游戏的设计与实现论文 2019-04-29
基于java实现的超级马里奥游戏 2019-04-29
keepalived 实现高可用，负载均衡 2019-04-29
linux发送邮件通知 2019-04-29
linux不删除文件：替换rm命令 2019-04-29
Centos6 搭建lnmp环境 2019-04-29
Hbase优化：使用压缩snappy,lz4 2019-04-29
maven 安装第三方jar包到本地仓库 2019-04-29
hbase数据结构模型 2019-04-29
Shell编程：return 返回脚本调用的状态码 2019-04-29
Hbase Shell 调用java代码：通过比较器，强过滤查询 2019-04-29
Linux防删除，恢复删除 2019-04-29
linux: shell脚本日常功夫 2019-04-29
linux脚本: 批量管理主机 2019-04-29
scala集合类型，函数 2019-04-29
spark: rdd的应用(scala api) 2019-04-29
spark: rdd的应用(java api) 2019-04-29
yarn: 资源调度机制 2019-04-29
spark的shell脚本分析 2019-04-29
白红宇的个人博客 - 记录点点滴滴的事 - 您是第 310024983 位访客
访问时间: 2024-05-02 13:27:58 访问IP: 18.191.5.239     Copyright © 2020 - 2023 blog.css8.cn 京ICP备2021015314号-1 手机版