文章目录
Hibernate_Day04
1. hibernate的检索方式
- Hibernate提供了很多种查询方式：hibernate共提供了五种查询方式
1.1 Hibernate的查询方式：OID查询
1.2 Hibernate的查询方式：对象导航检索
1.3 Hibernate的查询方式：HQL检索
- 不支持*写法
1.3.1准备工作：创建数据
@Test
public void demi01(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("张渣");
for (int i = 0; i < 10; i++) {
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("野结衣"+i);
linkMan.setCustomer(customer);
customer.getLinkMan().add(linkMan);
session.save(linkMan);
}
session.save(customer);
transaction.commit();
}
1.3.2：HQL简单查询
@Test
/**
* 简单查询
*/
public void demi02(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer").list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.3.3：HQL排序查询
@Test
/**
* 排序查询
*/
public void demi03(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//默认升序排列
//List<Customer> list = session.createQuery("from Customer order by cust_id").list();
//降序排列
List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.3.4：HQL条件查询
@Test
/**
* 条件查询
*/
public void demi04(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
/**
* 条件查询有两种方式
* 一、按照参数位置
* 二、按照名称绑定
*/
//一、按照参数位置
/* Query query = session.createQuery("from Customer where cust_name=? and cust_source=?");
query.setParameter(0, "张渣");
query.setParameter(1, "小广告");
List<Customer> list = query.list();
*/
//二、按照名称绑定
//注意 冒号和别名之间不能有空格
Query query = session.createQuery("from Customer where cust_name=:aaa and cust_source=:bbb");
query.setParameter("aaa", "张渣");
query.setParameter("bbb", "小广告");
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.3.5：HQL投影查询
@Test
/**
* 投影查询
*/
public void demi05(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
/* //单个属性 :返回一个object
List<Object> list = session.createQuery("select c.cust_name from Customer c").list();
for (Object object : list) {
System.out.println(object);
}*/
/*//多个属性:返回一个object数组
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));
}*/
/*
* 查询多个属性,想要将其封装到相应的对象中
* 1.在类中提供一个无参的构造方法(反射使用)
* 2.创建一个有参的构造方法(参数是想要显示的属性)
*/
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();
}
1.3.6：HQL分组统计查询
@Test
/**
* 分组统计查询
*/
public void demi07(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
/*//uniqueResult();返回一个结果,为Long类型
Object result = session.createQuery("select count(*) from Customer").uniqueResult();
System.out.println(result);*/
/* //uniqueResult();返回一个结果,为Long类型
List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source").list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}*/
//uniqueResult();返回一个结果,为Long类型
//分组统计过滤
List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source having count(*) >=2").list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
transaction.commit();
}
1.3.7：HQL分页查询
@Test
/**
* 分页查询
*/
public void demi06(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Query query = session.createQuery("from LinkMan");
//从第几条记录开始查
query.setFirstResult(10);
//查多少条记录
query.setMaxResults(10);
List<LinkMan> list = query.list();
for (LinkMan linkMan : list) {
System.out.println(linkMan);
}
transaction.commit();
}
1.3.8：HQL别名查询
@Test
/**
* 别名查询
*/
public void demi08(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//别名查询
List<Customer> list = session.createQuery("select c from Customer c").list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.4 Hibernate的查询方式：QBC检索
1.4.1：简单查询
@Test
/**
* 简单查询
*/
public void demi09(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.4.2：排序查询
@Test
/**
* 排序查询
*/
public void demi10(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//addOrder排序 Order.desc升序还是降序 按照cust_id排序
criteria.addOrder(Order.desc("cust_id"));
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.4.3：分页查询
@Test
/**
* 分页查询
*/
public void dem11(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
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);
}
transaction.commit();
}
1.4.4：条件查询
@Test
/**
* 条件查询
*/
public void demo12(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
/**
* 设置条件
* = eq
* > gt
* >= ge
* < lt
* <= le
* <> ne
* like
* in
* or
* and
*/
// 字段名 等于 xxx
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);
}
transaction.commit();
}
1.4.5：统计查询
@Test
/**
* 统计查询
*/
public void demo13(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
/**
* 设置条件
* add :普通条件，where后面的条件
* addOrder :排序
* setProjection :聚合函数 和 group by having
*/
/**
* Projections里面的参数
* * .rowCount():统计个数,类似于count(*)
* * .avg(propertyName):计算平均成绩,括号里面写字段名
* * .count(propertyName):统计个数,按照字段统计
* * .groupProperty(propertyName):按照字段分组
* * .max(propertyName):最大值
* * .min(propertyName):最小值
*/
criteria.setProjection(Projections.rowCount());
Long num = (Long) criteria.uniqueResult();
System.out.println(num);
transaction.commit();
}
1.4.6：离线条件查询SSH）—DetachedCriteria
@Test
/**
* 离线条件查询
*/
public void demo14(){
//获得离线条件查询对象
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
//添加条件
detachedCriteria.add(Restrictions.like("cust_name", "段%"));
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//获得Criteria对象
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}
transaction.commit();
}
1.5 Hibernate的查询方式：SQL检索
2. hibernate的抓取策略
2.1 Hibernate的抓取策略（优化）
2.1.1延迟加载的概述
延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。
2.1.2延迟加载的分类
- 类级别的延迟加载
- 指的是通过load方法查询某个对象的时候，是否采用延迟。session.load(Customer.class,1l);
- 类级别延迟加载通过上的lazy进行配置，如果让lazy失效
- 将lazy设置为false
- 将持久化类使用final修饰
- Hibernate. Initialize()
- 关联级别的延迟加载
- 指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。
Customer customer = session.get(Customer.class,1l);
customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。
- 指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。
- 抓取策略往往会和关联级别的延迟加载一起使用，优化语句。
2.1.3抓取策略
-
抓取策略的概述
1. 通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。 2. 通过<set>或者<many-to-one>上通过fetch属性进行设置 3. fetch和这些标签上的lazy如何设置优化发送的SQL语句 -
<set>上的fetch和lazy
-
fetch：抓取策略，控制SQL语句格式
1. select ：默认值，发送普通的select语句，查询关联对象 2. join ：发送一条迫切左外连接查询关联对象 3. subselect ：发送一条子查询查询其关联对象 -
lazy：延迟加载，控制查询关联对象的时候是否采用延迟
1. true ：默认值，查询关联对象的时候，采用延迟加载 2. false ：查询关联对象的时候，不采用延迟加载 3. extra ：及其懒惰。
- 在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。
- <many-to-one>上的fetch和lazy
-
fetch ：抓取策略，控制SQL语句格式。
1. select ：默认值，发送普通的select语句，查询关联对象。 2. join：发送一条迫切左外连接。 -
lazy ：延迟加载，控制查询关联对象的时候是否采用延迟。
1. proxy ：默认值，proxy具体的取值，取决于另一端的<class>上的lazy的值。 2. false：查询关联对象，不采用延迟。 3. no-proxy ：（不会使用） 4. 在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。
2.1.4批量抓取
- 什么是批量抓取
一批关联对象一起抓取，batch-size
- 测试批量抓取
来源：CSDN
作者：weixin_43912805
链接：https://blog.csdn.net/weixin_43912805/article/details/103489837