Hibernate的抓取策略---Hibernate查询方式的优化 延迟加载 + 抓取策略

public void demo03() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

// 查询1号客户

Customer customer = session.get(Customer.class, 1l);//查询1号客户并 发送一条查询客户的SQL语句

System.out.println(customer.getCust_name());

// 查看1号客户的每个联系人的信息

System.out.println(customer.getLinkMans().size());

tx.commit();

}

（3）extra:及其懒惰

当通过查询到customer去获取对应联系人的信息的时候，如果只是查询数量，懒加载extra，只会发送select count() from ，来统计数量，不会向上面flase的将对应的联系人都查询到。

@Test

// fetch=“select” lazy=“extra”

public void demo04() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

// 查询1号客户

Customer customer = session.get(Customer.class, 1l);// 发送一条查询1号客户的SQL语句

System.out.println(customer.getLinkMans().size());//发送select count() from …

tx.commit();

}

(4)join：发送一条迫切左外链接查询关联对象

当fetch="join"的时候在lazy当中配置都是没有作用的 --------> lazy失效

@Test

// 设置fetch=“join” lazy=true

public void demo05() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

Customer customer = session.get(Customer.class, 1l);// 发送一条迫切左外链接查询记录

System.out.println(customer.getCust_name());

System.out.println(customer.getLinkMans().size());//不发送

tx.commit();

}

设置fetch=“join” lazy=“false”

在这里true和false的效果一样，因为join的功能就是迫切左外链接，查询当前对象，并查询对应左边关联的对象，已经全部查询到，懒加载失效

(5)设置fetch=“subselect” lazy=“true”> subselect通过子查询来查找对应的联系人

先发送SQL查询对应的客户，然后在获取对应联系人信息的时候再发送一条SQL

@Test

// 设置fetch=“subselect” lazy=“true”

public void demo07() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

List list = session.createQuery(“from Customer”).list();//发送查询所有客户的SQL语句

for (Customer customer : list) {

System.out.println(customer.getCust_name());

System.out.println(customer.getLinkMans().size());//发送的一条子查询，通过对象的外键匹配对应的联系人

}

tx.commit();

}

（6）设置fetch=“subselect” lazy=“false” 查询客户并同时查询对应的联系人

发送查询客户的语句,通过子查询的方式统计对应的数据

@Test

// 设置fetch=“subselect” lazy=“false”

public void demo08() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

//查询客户并同时查询对应的联系人

List list = session.createQuery(“from Customer”).list();// 发送查询客户的语句,通过子查询的方式统计对应的数据

for (Customer customer : list) {

System.out.println(customer.getCust_name());

System.out.println(customer.getLinkMans().size());

}

tx.commit();

}

（7）在实际的开发当中，我们一般都采用默认值。fetch=select lazy=true

如果有特殊的需求，可能需要配置join。

3、< many-to-one > 上的fetch和lazy

fetch：抓取策略，控制SQL语句的个数

select ：（默认值）：发送普通的select语句来，查询对应关联的对象

join：发送一条迫切左外链接

lazy：延迟加载，控制查询关联对象的时候是否采用延迟

proxy:（默认值）：proxy具体的取值，取决于我们另一端上< class >上的lazy的值。如果class上的lazy是true

false:查询关联对象不采用延迟。

no-proxy:(不会使用)

测试方法：通过联系人查询客户

在LinkMan.hbm.xml当中配置对应的信息

（1）测试< many-to-one > 上的fetch和lazy默认值

先将Customer.hbm.xml当中的类级别的懒加载和抓取策略上的set的fecth和lazy的属性全部去掉

测试

先发送一条查询联系人的SQL语句，然后再发送一条查询下客户的SQL语句

@Test

// 默认值LinkMan当中的many-to-one上的默认值

public void demo01() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

LinkMan linkMan = session.get(LinkMan.class, 1l);//发送一条查询联系人的语句

System.out.println(linkMan.getLkm_name());

System.out.println(linkMan.getCustomer().getCust_name());//发送一条查询客户的SQL语句

tx.commit();

}

然后在LinkMan.hbm.xml当中配置, <many-to-one>配置fetch="select" lazy="proxy"

再次运行代码，结果和上述的结果一直则，证明，其默认值为fetch="select" lazy="proxy"

（2）配置< many-to-one >上 <many-to-one>配置fetch="select" lazy="false"

发送SQL查询联系人的信息并发送SQL查询对应的客户

@Test

// 配置fetch=“select” lazy=“false”

public void demo03() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

//发送两个select语句

LinkMan linkMan = session.get(LinkMan.class, 1l);//发送SQL查询联系人的信息并发送SQL查询对应的客户

System.out.println(linkMan.getLkm_name());

System.out.println(linkMan.getCustomer().getCust_name());

tx.commit();

}

（3）< many-to-one >配置fetch=“join” lazy=“失效”

发送一条迫切左外链接去查询联系人所关联的客户

@Test

// 配置fetch=“join” lazy=“失效”

public void demo04() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

// 发送一条迫切左外链接去查询联系人所关联的客户

LinkMan linkMan = session.get(LinkMan.class, 1l);

System.out.println(linkMan.getLkm_name());

System.out.println(linkMan.getCustomer().getCust_name());

tx.commit();

}

false和proxy效果一样

（4）proxy具体的取值，取决于我们另一端上< class >上的lazy的值。如果class上的lazy是true

a、设置 LinkMan.hbm.xml和Customer.hbm.xml

发送两条查询SQL语句

LinkMan.hbm.xml

Customer.hbm.xml

当中Customer.hbm.xml当中lazy为ture的时候，相当于< many-to-one >当中的lazy=“false”

// 配置fetch=“select” lazy=“proxy”

public void demo02() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

LinkMan linkMan = session.get(LinkMan.class, 1l);// 发送一条查询联系人的语句

System.out.println(linkMan.getLkm_name());

System.out.println(linkMan.getCustomer().getCust_name());

tx.commit();

}

b、 LinkMan.hbm.xml当中的值不变，改变Customer.hbm.xml当中的数值

当class当中的lazy等于false的时候，当中< many-to-one >相当于lazy=“false”

再次运行上面代码，同时发送两个查询SQL语句，查询联系并查询客户

三、批量抓取策略。

---

1、什么是批量抓取

一批关联对象一起进行抓取，batch-size

一次获取多个客户的联系人信息

2、测试批量抓取：通过客户获取对应的联系人

（1）默认情况下：通过客户获取对应的联系人

@Test

// 在获取客户的时候同时批量去抓取联系人

public void demo01() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

List list = session.createQuery(“from Customer”).list();

for (Customer customer : list) {

System.out.println(customer.getCust_name());

for (LinkMan linkman : customer.getLinkMans()) {

System.out.println(linkman.getLkm_name());

}

}

tx.commit();

}

会发送很多查询语句，效率比较底下

（2）在一 的一方配置batch-size=“”

Customer.hbm.xml

batch-size="“代表当前对象是几个为一组发送SQL语句，超出的自动增加发送SQL语句的数量

发送SQL数量等于通过外键要查询的数据总数除以batch-size=”" 当中的数，不够加一

batch-size=""等于外键种类数量是最好的情况

@Test

// 在获取客户的时候同时批量去抓取联系人

public void demo01() {

Session session = HibernateUtils.getCurrentSession();

Transaction tx = session.beginTransaction();

List list = session.createQuery(“from Customer”).list();

for (Customer customer : list) {

System.out.println(“-------------------------------”);

System.out.println(customer.getCust_name());

System.out.println(“-------------------------------”);

for (LinkMan linkman : customer.getLinkMans()) {

System.out.println(linkman.getLkm_name());

}

}

tx.commit();

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

总结

大型分布式系统犹如一个生命，系统中各个服务犹如骨骼，其中的数据犹如血液，而Kafka犹如经络，串联整个系统。这份Kafka源码笔记通过大量的设计图展示、代码分析、示例分享，把Kafka的实现脉络展示在读者面前，帮助读者更好地研读Kafka代码。

麻烦帮忙转发一下这篇文章+关注我

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！**

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

总结

大型分布式系统犹如一个生命，系统中各个服务犹如骨骼，其中的数据犹如血液，而Kafka犹如经络，串联整个系统。这份Kafka源码笔记通过大量的设计图展示、代码分析、示例分享，把Kafka的实现脉络展示在读者面前，帮助读者更好地研读Kafka代码。

麻烦帮忙转发一下这篇文章+关注我

[外链图片转存中…(img-5K9uGVoH-1711617715564)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！