Hibernate的查询方式（大全）（检索方式）OID查询+ HQL检索 +QBC检索+SQL检索

在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<LinkMan> linkMans = customer.getLinkMans();//通过对象获取到集合

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

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

Hibernate环境搭建和配置另一篇文章
https://blog.csdn.net/qq_44757034/article/details/106242492
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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Object> 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<Object[]> 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<Customer> 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<LinkMan> 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<Object[]> 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<Object[]> 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<Object[]> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<Customer> 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<LinkMan> 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<Customer> 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<Customer> 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层与数据库建立连接

//绑定session
criteria.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<Customer> 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<Object[]> 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<Customer> list = sqlQuery.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tx.commit();
	}
}