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

chenssss 2010-11-08

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

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

首先建立测试数据库

CREATE TABLE certificate (

idvarchar(100)NOTNULLdefault'',

descriptionvarchar(100)default'',

PRIMARYKEY(id)

);

CREATE TABLE student (

team_idvarchar(100)default'',

idvarchar(100)NOTNULLdefault'',

namevarchar(20)default'',

cardIdvarchar(20)NOTNULLdefault'',

ageint(11)default'0',

PRIMARYKEY(id)

);

CREATETABLEteam(

idvarchar(100)NOTNULLdefault'',

teamNamevarchar(100)default'',

PRIMARYKEY(id)

);

INSERTINTOstudentVALUES

('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 ............{

privateStringid;

privateStringdescription;

    private Student stu;

    public Student getStu() ............{

returnstu;

    }

    public void setStu(Student stu) ............{

this.stu=stu;

    }

publicStringgetDescription()............{

returndescription;

    }

    public void setDescription(String description) ............{

this.description=description;

    }

    public String getId() ............{

returnid;

    }

    public void setId(String id) ............{

this.id=id;

}

}

package Search.immediately;

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

publicclassTeam............{

privateStringid;

privateSetstudents=newHashSet();

privateStringteamName;

privateSettests;

publicSetgetTests()............{

returntests;

}

publicvoidsetTests(Settests)............{

this.tests=tests;

    }

    public String getId() ............{

returnid;

    }

    public void setId(String id) ............{

this.id=id;

    }

    public String getTeamName() ............{

returnteamName;

    }

    public void setTeamName(String name) ............{

this.teamName=name;

    }

    public Set getStudents() ............{

returnstudents;

    }

    public void setStudents(Set students) ............{

this.students=students;

}

}

package Search.immediately;

public class Certificate ............{

privateStringid;

privateStringdescription;

    private Student stu;

    public Student getStu() ............{

returnstu;

    }

    public void setStu(Student stu) ............{

this.stu=stu;

    }

publicStringgetDescription()............{

returndescription;

    }

    public void setDescription(String description) ............{

this.description=description;

    }

    public String getId() ............{

returnid;

    }

    public void setId(String id) ............{

this.id=id;

}

}

HBM文件

student.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

MappingfileautogeneratedbyMyEclipse-HibernateTools

-->

<hibernate-mapping package="Search.batch.immediately" >

    <class name="Student" table="student" lazy="false">

<idname="id"column="id"unsaved-value="null">

<generatorclass="uuid.hex"></generator>

       </id>

       <property name="cardId" column="cardId"></property>

<propertyname="name"column="name"></property>

<propertyname="age"column="age"></property>

<!--为了设置student-certificate的延迟1对1，设置class的lazy="no-proxy"-->

<one-to-onename="cer"

class="Search.batch.immediately.Certificate"

constrained="true"

lazy="no-proxy"

outer-join="false"

cascade="all">

</one-to-one>

<many-to-onename="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"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

MappingfileautogeneratedbyMyEclipse-HibernateTools

-->

<hibernate-mappingpackage="Search.batch.immediately">

<!--为了设置student-certificate的延迟1对1，设置class的lazy="true"-->

<classname="Certificate"table="certificate"lazy="true">

<idname="id"column="id">

<generatorclass="foreign">

<paramname="property">stu</param>

</generator>

       </id>

<propertyname="description"column="description"></property>

<one-to-onename="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"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

MappingfileautogeneratedbyMyEclipse-HibernateTools

-->

<hibernate-mappingpackage="Search.batch.immediately">

<classname="Team"table="team"lazy="false">

<idname="id"column="id">

<generatorclass="uuid.hex"></generator>

</id>

<propertyname="teamName"column="teamName"></property>

<!--需要批量加载，设置batch-size="2"-->

<setname="students"

lazy="false"

inverse="true"

outer-join="false"

>

<keycolumn="team_id"></key>

<one-to-manyclass="Search.batch.immediately.Student"/>

</set>

</class>

</hibernate-mapping>

测试代码：

package Search.batch.immediately;

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

import org.hibernate.Query;

importorg.hibernate.Session;

importorg.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class Test ...{

publicstaticvoidmain(String[]args)...{

Teamteam=null;

StringfilePath=System.getProperty("user.dir")+File.separator+"src/Search/batch/immediately"+File.separator+"hibernate.cfg.xml";

Filefile=newFile(filePath);

SessionFactorysessionFactory=newConfiguration().configure(file).buildSessionFactory();

Sessionsession=sessionFactory.openSession();

Queryquery=session.createQuery("fromTeamt");

        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"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

MappingfileautogeneratedbyMyEclipse-HibernateTools

-->

<hibernate-mappingpackage="Search.batch.immediately">

<classname="Team"table="team"lazy="false">

<idname="id"column="id">

<generatorclass="uuid.hex"></generator>

</id>

<propertyname="teamName"column="teamName"></property>

<!--需要批量加载，设置batch-size="2"-->

<setname="students"

lazy="false"

inverse="true"

outer-join="false"

batch-size="2"

>

<keycolumn="team_id"></key>

<one-to-manyclass="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"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!--

MappingfileautogeneratedbyMyEclipse-HibernateTools

-->

<hibernate-mappingpackage="Search.batch.immediately">

<classname="Team"table="team"lazy="false">

<idname="id"column="id">

<generatorclass="uuid.hex"></generator>

</id>

<propertyname="teamName"column="teamName"></property>

<!--需要批量加载，设置batch-size="2"-->

<setname="students"

lazy="true"

inverse="true"

outer-join="false"

batch-size="2"

>

<keycolumn="team_id"></key>

<one-to-manyclass="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查询，而是再缓冲中查询

chenssss

chenssss

相关推荐

【Hibernate 检索策略】

SessionFactory sessionFactory = null;Session session = null;Transaction tx = null;List<Customer> list = criteria.list();tx

LetonLIU / 0评论 2020-02-11

Hibernate part 12：多对一/一对一检索策略

1) 当fetch 取值 join ，采用迫切左外连接 lazy 被忽略 针对 get/load 有效 如果Query ， fetch="join" 被忽略， lazy 将重新生效 2) 当fetch取值 select ，产生多条SQL

abguorui0 / 0评论 2015-03-08

Hibernate_检索策略

Hibernate的检索策略包括类级别检索策略和关联级别检索策略。在Hibernate映射文件中，通过在<class>上配置lazy属性来确定检索策略。关联级别检索策略有立即检索、延迟检索和迫切左外连接检索。对于关联级别检索，又可分为一对多和多

hhboyggyy / 0评论 2014-08-25

Hibernate检索策略

--[endif]-->立即检索 fetch=”select”。就是在检索数据时立即返回实际需要的数据，在hibernate中处于性能的考虑默认不使用立即检索，只有当映射文件中指定lazy=”false”时才使用立即检索策略。和立即加载一样都是在检索

万星明 / 0评论 2013-06-24

随书笔记之hibernate 检索策略

多和多对多默认为立即检索策略），影响load，get，find方法。4 hibernate 可以使用编程的方式显示设置检索策略。5 如果一个类是采用延迟加载的话，在执行load方法是，不会立即查询customer表，而只是返回该类的。代理类实例，该实例只有

haojusheng / 0评论 2012-12-04

hibernate n+1

在Session的缓存中存放的是相互关联的对象图。默认情况下，当Hibernate从数据库中加载Customer对象时，会同时加载所有关联的Order对象。以Customer和Order类为例，假定ORDERS表的CUSTOMER_ID外键允许为null，

追求 / 0评论 2011-06-28

hibernate中lazy =true

Hibernate的检索策略包括类级别检索策略和关联级别检索策略。在Hibernate映射文件中，通过在<class>上配置lazy属性来确定检索策略。关联级别检索策略有立即检索、延迟检索和迫切左外连接检索。对于关联级别检索，又可分为一对多和多

平步星云 / 0评论 2011-05-05

什么叫n+1次select查询问题?

什么叫n+1次select查询问题?在Session的缓存中存放的是相互关联的对象图。默认情况下，当Hibernate从数据库中加载Customer对象时，会同时加载所有关联的Order对象。以Customer和Order类为例，假定ORDERS表的CUS

chenssss / 0评论 2011-04-05

Hibernate中的数据检索策略概述

我们知道，Hiberante是一个ORM工具，它使得我们能够直接去操纵对象而不是数据库中表。Hibernate的数据检索策略也是给予对对象的操作的。数据检索策略主要包括一下几种：立即加载，延迟加载，预先抓取和批量加载。1立即检索：立即检索的时候需要在配置文

simon曦 / 0评论 2011-04-02

Hibernate的检索策略

Hibernate的检索策略包括类级别检索策略和关联级别检索策略。在Hibernate映射文件中，通过在<class>上配置lazy属性来确定检索策略。关联级别检索策略有立即检索、延迟检索和迫切左外连接检索。对于关联级别检索，又可分为一对多和多

nameFay / 0评论 2011-03-29

Hibernate检索策略

类级别检索策略：Session的load()和get()方法，以及Query的HQL语句直接指定检索的是Customer对象，对Customer对象到底才用是立即检索还是延迟检索。默认是延迟检索，影响的只是load()方法。程序代码中的检索策略会覆盖映射文

阳光丶不锈 / 0评论 2010-12-22

hibernate 内连接 外连接区别

p=490 在下绝无抄袭之意，觉得讲得很不错，于是就收藏下来。关系型数据库之所以强大，其中一个原因就是可以统一使用表来管理同类数据信息，并且可以在相关数据之间建立关系。同样作为一种关系型数据库的持久层框架，Hibernate也对连接查询提供了丰富的支持，在

TomasEdision / 0评论 2010-11-08

精通hibernate学习笔记（7）[检索策略]

a.类级别检索策略：session.load,session.get,session.find方法，直接指定检索的是Customer对象，对Customer对象到底采用立即检索，还是延迟检索？Hibernate还允许在应用程序中以编程方式显式设定检索策略，

神儿童 / 0评论 2010-10-19

Hibernate的检索策略

Hibernate的检索策略包括类级别检索策略和关联级别检索策略。在 Hibernate映射文件中，通过在上配置lazy属性来确定检索策略。对于Session的检索方式，类级别检索策略仅适用于load方法;也就说，对于get、qurey检索，持久化对象都会

xhljames / 0评论 2010-08-11

Hibernate 检索策略

Hibernate的检索策略包括类级别检索和关联级别的检索。立即加载检索方法指定的对象。如果程序加载一个持久化对象的目的是为了访问它的属性，可以采用立即检索策略。将<class中的lazy设置为false。当需要加载一个持久化对象时，系统不会立即加载

xing00 / 0评论 2010-05-10

Hibernate的检索策略

Hibernate的检索策略包括类级别检索策略和关联级别检索策略。在Hibernate映射文件中，通过在<class>上配置lazy属性来确定检索策略。关联级别检索策略有立即检索、延迟检索和迫切左外连接检索。对于关联级别检索，又可分为一对多和多

hhboyggyy / 0评论 2010-04-08

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

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

土豆的小秘密 / 0评论 2008-05-22

Hibernate的检索策略

所谓立即检索就是立即装载和初始化检索方法指定的对象,即使Session关闭了,依然可以被正常访问.立即检索策略的启用是通过在映射配置文件中将lazy属性值得设置为"false"来实现的.在Hibernate3.0中lazy的默认值为&q

DOVEty / 0评论 2008-05-20

概括Hibernate检索策略

Hibernate还是比较常用的，于是我研究了一下Hibernate检索策略，在这里拿出来和大家分享一下，希望对大家有用。Hibernate检索策略包括类级别检索策略和关联级别检索策略。对于关联级别检索，又可分为一对多和多对多、多对一和一对一两种情况讨论。

feiyangtianyao / 0评论 2009-09-25

Hibernate配置---检索策略

Hibernate是一个持久层的框架，不依赖任何容器，支持对象到数据库表的映射，ORM。支持开发中的增删改查操作，将基本的JDBC操作进行封装，可以通过配置hibernate.cfg.xml来方便的切换数据库。支持数据库连接池，防止高并发导致系统响应慢和系

两个蝴蝶飞 / 0评论 2011-12-06

Hibernate —— 检索策略

默认为 true，即为延迟检索。默认情况下，通过 load() 方法获取到的对象是一个代理对象，Hibernate 创建代理对象时，仅会初始化 OID。在第一次访问非 OID 属性时，Hibernate 会初始化代理类实例。取值为 extra 时，会尽可能

编程爱好者联盟 / 0评论 2016-10-13