Hibernate检索策略学习之--批量加载

最新推荐文章于 2023-09-18 13:35:00 发布
最新推荐文章于 2023-09-18 13:35:00 发布
阅读量1.2k 收藏
点赞数
分类专栏： 经验技巧之Hibernate 文章标签： hibernate generator class encoding import table
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daryl715/article/details/1907637
版权

所谓批量加载，即把原本要发送的SQL分批统一发送，比如说原本要发送100条SQL,如果设置batch-size=3,则只需要发送100/3+1=34条，可以提高效率

批量加载分为延迟加载和立即加载，先说立即加在

首先建立测试数据库

 



 CREATE   TABLE  certificate (
  id  varchar ( 100 )  NOT   NULL   default   '' ,
  description  varchar ( 100 )  default   '' ,
   PRIMARY   KEY   (id)
);





 CREATE   TABLE  student (
  team_id  varchar ( 100 )  default   '' ,
  id  varchar ( 100 )  NOT   NULL   default   '' ,
  name  varchar ( 20 )  default   '' ,
  cardId  varchar ( 20 )  NOT   NULL   default   '' ,
  age  int ( 11 )  default   ' 0 ' ,
   PRIMARY   KEY   (id)
);


 CREATE   TABLE  team (
  id  varchar ( 100 )  NOT   NULL   default   '' ,
  teamName  varchar ( 100 )  default   '' ,
   PRIMARY   KEY   (id)
);


 INSERT   INTO  student  VALUES  
( ' 5 ' , ' 1 ' , ' spark ' , ' 200211332 ' , 13 ),
( ' 4 ' , ' 2 ' , ' jerry ' , ' 200233332 ' , 23 ),
( ' 3 ' , ' 3 ' , ' adidas ' , ' 200231332 ' , 33 ),
( ' 2 ' , ' 4 ' , ' zhouxingchi ' , ' 200231132 ' , 43 ),
( ' 1 ' , ' 5 ' , ' tomclus ' , ' 200512345 ' , 53 ),
( ' 1 ' , ' 6 ' , ' tom ' , ' 200511345 ' , 63 );

 INSERT   INTO  team  VALUES  
( ' 5 ' , ' team5 ' ),
( ' 4 ' , ' team4 ' ),
( ' 3 ' , ' team3 ' ),
( ' 2 ' , ' team2 ' ),
( ' 1 ' , ' team1 ' );

 INSERT   INTO  certificate  VALUES  
( ' 1 ' , ' card1 ' ),
( ' 2 ' , ' card2 ' ),
( ' 3 ' , ' card3 ' ),
( ' 4 ' , ' card4 ' ),
( ' 5 ' , ' card5 ' ),
( ' 6 ' , ' card6 ' );

 

建立POJO对象

 

package  Search.immediately;

 public   class  Certificate ......... {
    private String id;
    private String description;
    private Student stu;

    public Student getStu() .........{
        return stu;
    }

    public void setStu(Student stu) .........{
        this.stu = stu;
    }


    public String getDescription() .........{
        return description;
    }

    public void setDescription(String description) .........{
        this.description = description;
    }

    public String getId() .........{
        return id;
    }

    public void setId(String id) .........{
        this.id = id;
    }
}



package  Search.immediately;

 import  java.util.HashSet;
 import  java.util.Set;


 public   class  Team ......... {
    private String id;
    private Set students=new HashSet();
    private String teamName;
    private Set tests;
  
    public Set getTests() .........{
        return tests;
    }
 
    public void setTests(Set tests) .........{
        this.tests = tests;
    }

    public String getId() .........{
        return id;
    }

    public void setId(String id) .........{
        this.id = id;
    }

    public String getTeamName() .........{
        return teamName;
    }

    public void setTeamName(String name) .........{
        this.teamName = name;
    }

    public Set getStudents() .........{
        return students;
    }

    public void setStudents(Set students) .........{
        this.students = students;
    }
}



package  Search.immediately;

 public   class  Certificate ......... {
    private String id;
    private String description;
    private Student stu;

    public Student getStu() .........{
        return stu;
    }

    public void setStu(Student stu) .........{
        this.stu = stu;
    }


    public String getDescription() .........{
        return description;
    }

    public void setDescription(String description) .........{
        this.description = description;
    }

    public String getId() .........{
        return id;
    }

    public void setId(String id) .........{
        this.id = id;
    }
}

 

HBM文件

student.hbm.xml

 

<? xml version="1.0" encoding="utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--  
    Mapping file autogenerated by MyEclipse - Hibernate Tools
 -->
< hibernate-mapping  package ="Search.batch.immediately"   >

     < class  name ="Student"  table ="student"  lazy ="false" >
        < id  name ="id"  column ="id"  unsaved-value ="null" >
          < generator  class ="uuid.hex" ></ generator >
        </ id >

        < property  name ="cardId"  column ="cardId" ></ property >
        < property  name ="name"  column ="name" ></ property >
        < property  name ="age"  column ="age" ></ property >
        <!-- 为了设置student-certificate的延迟1对1，设置class的lazy="no-proxy" -->
        < one-to-one  name ="cer"  
                   class ="Search.batch.immediately.Certificate"
                   constrained ="true"  
                   lazy ="no-proxy"
                   outer-join ="false"  
                   cascade ="all" >
        </ one-to-one >
      
        < many-to-one  name ="team"  
                    column ="team_id"
                    outer-join ="false"  
                    class ="Search.batch.immediately.Team" ></ many-to-one >
       </ class >
</ hibernate-mapping >

 

Certificate.hbm.xml

 

<? xml version="1.0" encoding="utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--  
    Mapping file autogenerated by MyEclipse - Hibernate Tools
 -->
< hibernate-mapping  package ="Search.batch.immediately"   >  
     <!-- 为了设置student-certificate的延迟1对1，设置class的lazy="true" -->
     < class  name ="Certificate"  table ="certificate"  lazy ="true" >
        < id  name ="id"  column ="id" >
          < generator  class ="foreign" >
            < param  name ="property" > stu </ param >
          </ generator >
        </ id >


        < property  name ="description"  column ="description" ></ property >
        < one-to-one  name ="stu"  
                   class ="Search.batch.immediately.Student"
                   outer-join ="false"  
                   constrained ="true" >
        </ one-to-one >
       </ class >
</ hibernate-mapping >

 

Team.hbm.xml

 

<? xml version="1.0" encoding="utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--  
    Mapping file autogenerated by MyEclipse - Hibernate Tools
 -->
< hibernate-mapping  package ="Search.batch.immediately"   >
     < class  name ="Team"  table ="team"  lazy ="false" >
        < id  name ="id"  column ="id" >
          < generator  class ="uuid.hex" ></ generator >
        </ id >
        < property  name ="teamName"  column ="teamName" ></ property >
         <!-- 需要批量加载，设置batch-size="2" -->
        < set  name ="students"  
            lazy ="false"  
            inverse ="true"  
            outer-join ="false"
            >
          < key  column ="team_id" ></ key >
          < one-to-many  class ="Search.batch.immediately.Student" />
        </ set >
       </ class >
</ hibernate-mapping >

 

测试代码：

 

package  Search.batch.immediately;

 import  java.io.File;
 import  java.util.List;

 import  org.hibernate.Query;
 import  org.hibernate.Session;
 import  org.hibernate.SessionFactory;
 import  org.hibernate.cfg.Configuration;

 public   class  Test  {


    public static void main(String[] args) {
        Team team=null;
        String filePath=System.getProperty("user.dir")+File.separator+"src/Search/batch/immediately"+File.separator+"hibernate.cfg.xml";
        File file=new File(filePath);
        SessionFactory sessionFactory=new Configuration().configure(file).buildSessionFactory();
        Session session=sessionFactory.openSession();
        Query query=session.createQuery("from Team t");
        List resultList=query.list();


}

 

运行，结果如下：

Hibernate: select team0_.id as id2_, team0_.teamName as teamName2_ from team team0_


Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?

有5条查询student的SQL(本身有6个学生，但有两个学生属于一个team)
可以看到，这是典型的立即加在，取得team对象后，把team所包含的student取出，如果有100个学生，则会执行100个SQL,这是很没有效率的

我们修改Team的hbm文件，为其配置批量加载student的配置（1对多在set标签上配置，多对1在class标签上配置）

 

<? xml version="1.0" encoding="utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--  
    Mapping file autogenerated by MyEclipse - Hibernate Tools
 -->
< hibernate-mapping  package ="Search.batch.immediately"   >
     < class  name ="Team"  table ="team"  lazy ="false" >
        < id  name ="id"  column ="id" >
          < generator  class ="uuid.hex" ></ generator >
        </ id >
        < property  name ="teamName"  column ="teamName" ></ property >
         <!-- 需要批量加载，设置batch-size="2" -->
        < set  name ="students"  
            lazy ="false"  
            inverse ="true"  
            outer-join ="false"
            batch-size ="2"
            >
          < key  column ="team_id" ></ key >
          < one-to-many  class ="Search.batch.immediately.Student" />
        </ set >
       </ class >
</ hibernate-mapping >

 

再次运行测试程序，结果如下：

Hibernate: select team0_.id as id2_, team0_.teamName as teamName2_ from team team0_

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id in (?, ?)

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_,
students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id in (?, ?)

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?

可以看到，查询student只用了3条SQL(5/batch-size+1=3),

 

如果team对student是延迟加载的，会使什么效果呢，会是这样，我们加载team1时候，由于batch-size=2,所以加载team1就同时批量加载了team2,同理，加载team3时候也就加载了team4，最后再加载team5,  而这些数据都已经在hibernate session的缓存中了

修改team.hbm.xml 配置好lazy="true"

 

<? xml version="1.0" encoding="utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--  
    Mapping file autogenerated by MyEclipse - Hibernate Tools
 -->
< hibernate-mapping  package ="Search.batch.immediately"   >
     < class  name ="Team"  table ="team"  lazy ="false" >
        < id  name ="id"  column ="id" >
          < generator  class ="uuid.hex" ></ generator >
        </ id >
        < property  name ="teamName"  column ="teamName" ></ property >
         <!-- 需要批量加载，设置batch-size="2" -->
        < set  name ="students"  
            lazy ="true"  
            inverse ="true"  
            outer-join ="false"
            batch-size ="2"
            >
          < key  column ="team_id" ></ key >
          < one-to-many  class ="Search.batch.immediately.Student" />
        </ set >
       </ class >
</ hibernate-mapping >

 

运行测试程序，结果如下：

Hibernate: select team0_.id as id2_, team0_.teamName as teamName2_ from team team0_

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id in (?, ?)
team1:2
team2:1

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id in (?, ?)
team3:1
team4:1

Hibernate: select students0_.team_id as team5_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.cardId as cardId1_0_, students0_.name as name1_0_, students0_.age as age1_0_, students0_.team_id as team5_1_0_ from student students0_ where students0_.team_id=?
team5:1

其中可以砍到team2和team4的数据是批量加载来的，已经保存在缓存中，所以读取其students集合对象是，虽然是延迟加载，但不再会去发送SQ查询，而是再缓冲中查询

daryl715
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据的批量加载
qq_58586923的博客
12-01 440
通常，对于几千条甚至几万条记录的数据迁移而言，采取DML（数据操纵语言）的INSERT语句能够很好地将数据迁移到目标数据库中。然而，当数据迁移量过于庞大时，就不能使用INSERT语句了，因为执行INSERT,UPDATE以及DELETE语句的操作都会生成事务日志，事务日志的生成会减慢加载的速度，故需要针对数据采取批量加载操作。四，查看结果及表weibo_user的创建。表weibo_user的创建。二，配置“表输入”控件。三，配置“表输出”控件。“数据库字段”选项卡。
hibernate-------加载策略
qq_32659773的博客
04-13 141
1.3.1 类级别的加载策略 get：立即检索。get方法一执行，立即查询所有字段的数据。 load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值才查询 如果在类级别上配置lazy为true,那load方法就会即时加载，否则为延时加载 1.3.2 关联级别的加载策略 关联级别的集合加载的策略是...
hibernate之批量加载
各研发管理
10-07 77
Hibernate 批量加载（立即、延迟）
baobeituping的专栏
12-10 113
一、批量立即加载 以上面的例子为例： Team对学生采取的是立即加载   客户端： Session session = SessionUtil.getSession();  Transaction tran = session.beginTransaction();  Query query = session.createQuery("from Team");  List list =...
hibernate加载策略
m0_46699799的博客
08-12 152
hibernate加载策略对象的三种状态一级缓存，快照一级缓存快照加载策略立即加载延迟加载 对象的三种状态 hibernate管理的对象 临时状态 (比如和陌生人对话) 持久状态 （比如我们和朋友之间的关系） 游离状态 （比如我们与之前是朋友但是现在不怎么联系了的人的关系） 具体如下图 通过实例化或者调用这些方法来实现三种状态之间的操作 当一个对象/实体类被new了一下并把这个实体类/对象加载到session中之后它们就属于临时状态，临时状态的内容通过hibernate进行save保存这个动作之后就会
day36-hibernate检索和优化 02-Hibernate检索方式：简单查询及别名查询
04-26
本教程将深入探讨"day36-hibernate检索和优化 02-Hibernate检索方式：简单查询及别名查询"的主题，通过源码分析和实际工具的应用，来提升数据库查询的效率。 首先，我们了解Hibernate的检索方式。在Hibernate中，...
HIBERNATE检索策略
01-07
标题：“HIBERNATE检索策略” 描述：本文深入解析了HIBERNATE的检索策略，为读者提供了一条清晰的学习路径，重点分析了HIBERNATE中的抓取策略及其应用场景，帮助开发者更有效地管理和优化数据加载过程。 在...
【学习笔记-SSH框架】Hibernate高级-笔记02-1-N关联检索策略
AlanLee97的博客
10-05 123
Hibernate高级-笔记02-1-N关联检索策略 目录 关联策略简介 立即加载和延迟加载 批量检索 预先抓取 0. 关联策略简介 Hibernate中的关联检索方式有以下三种： 立即加载 延迟加载 预先抓取 以Customer类和Order类为例 Customer类 public class Customer implements Serializable { /** ...
SSH笔记-Hibernate的检索策略(lazy、fetch、batch-size)
oyy的博客
04-19 253
1、分为两部分： ①类级别检索策略，大概了解检索策略(代码所在包com.demo.sshtest) ②检索策略的lazy、fetch、batch-size属性使用(代码所在包com.demo.sshtest2) 2、检索策略： ①立即检索，立即加载检索方法指定的对象 ②延迟检索，延迟加载检索方法指定的对象，在使用具体属性值时，才进行加载(这个时候会执行查询语句) 3、检索策略使用场景：...
7.数据的批量加载
akina1的博客
12-02 496
批量加载
批量加载性能
DBASun
10-11 440
在大量加载数据是遇到性能问题，检查后发现客户采用的是单条插入单条提交这种最缓慢的方式，为了给客户说明优化效果，现场做了几个代码。 最简单的优化方式莫过于减少COMMIT频度，而最优化的方式是采用批量插入的方式，简单的测试代码如下： SQL> CREATE TABLE T_INSERT (ID NUMBER, NAME VARCHAR2(30)); Table created. SQ
《数据清洗》期末考试模拟题
qq_46618641的博客
11-21 4847
《数据清洗》期末考试模拟题，选择，判断，填空，简答。
第七章 Kettle-数据加载&全量加载&增量加载&批量加载
qq_56941108的博客
11-14 2238
数据的预处理过程，除了包括数据抽取、数据本身的清洗与检验以及数据转换操作，还包括数据加载操作，数据加载是数据预处理过程的最后一个步骤，主要是负责将清洗检验、转换后的高质量数据加载到目标数据库中。 数据的加载机制与数据的抽取机制相类似，数据的加载机制可以分为全量加载和增量加载。其中，全量加载是指将目标数据表中的数据全部删除后，进行数据加载的操作；而增量加载是指目标表只加载源数据表中变化的数据，其中变化的数据包含新增、修改和删除的数据。
KingbaseES数据库批量加载数据的最佳方法
最新发布
lyu1026的博客
09-18 244
前言 本文讨论在KingbaseES数据库服务器中批量加载数据的方法，以及空数据库中的初始数据加载和增量数据加载的最佳做法。 批量加载方法 以下数据加载方法按照从最耗时到最不耗时的顺序排列： 1.运行单记录 INSERT 命令。 2.在每次提交中分批成 100 到 1000 行。可以使用事务块在每次提交时包含多条记录。 3.运行INSERT命令，使用多个行的value值。 4.运行 COPY 命...
NLP——如何批量加载数据
GeekZW的博客
10-14 1286
NLP——如何批量加载数据 问题背景：利用Bert、Albert、Roberta或腾讯词向量等预训练模型，去微调或者特征集成各类NLP子任务，并转存为pb模型后，如何进行批量预测，以提升性能，缩短耗时呢？当然是batch预测了！为了方便以后使用，个人抽成一个简单的类。 资源： 源代码：改自苏神的bert4keras源码文件夹examples中的情感分析例子 如果不熟悉子类继承父...
Hibernate 实现批量添加数据
leap fly 技术博客
07-25 3960
Hibernate 实现批量添加数据 1.Hibernate_016_BatchAddData程序目录结构： 2.lib目录下所引入的jar包： 3.MedicineDao.java源代码： [java] view plaincopy package com.xqh.dao;    import java.util.List;    impor
hbase的高级特性之Bulk Loading 批量加载
枣泥馅的博客
04-20 1146
hbase的高级特性之Bulk Loading 批量加载 hbase的批量加载工功能是为了 提高数据存储的性能，它是通过csv文件来批量加载 hbase批量加载的本质是将csv文件转换成hbase的hfile，然后把hfile映射到hbase中 第一步：创建表 在hbase命令行模式下创建表 create ‘emp’,‘info’,‘money’ 第二步：把csv文件转换成hfile 使用Impo...
优化查询：批量加载与Hibernate缓存技术解析
"该资源是一个关于使用Hibernate提升查询性能的教程，主要讲解了批量加载、Hibernate缓存、对象状态、检索策略以及相关的实践应用。通过批量加载，可以提高数据读取效率；而Hibernate的缓存机制则能进一步优化数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值