- 浏览: 2309218 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (314)
- JAVA基础知识 (54)
- Java-IO/FIle (16)
- Java-JDBC (4)
- JAVA-新增特性-注解 (3)
- Java-枚举 (2)
- Java-泛型 (1)
- Java-多线程 (15)
- Java-XML (4)
- Java-JMS(消息服务) (4)
- Java-JVM (0)
- Web Service服务 (7)
- Jsp (10)
- js (18)
- Struts框架 (11)
- Spring框架 (29)
- Hibernate框架 (28)
- Spring Boot框架 (2)
- ExtJS前端框架 (29)
- Jquery js库 (8)
- JUnit框架 (8)
- Selenium 测试 (1)
- NoSql---Redis (6)
- ORACLE数据库 (45)
- MySQL数据库 (4)
- tomcat (3)
- Nginx反向代理服务器 (4)
- web应用服务器通用知识 (3)
- 开发工具IDE (14)
- UML建模 (1)
- SVN CVS 版本管理 (6)
- git 分布式版本管理 (4)
- 报表设计 (5)
- 文件上传下载 (2)
- 数据算法 (1)
- 存储过程 (5)
- JSON 相关 (1)
- OGNL表达式 (3)
- Util工具包 (9)
- 设计模式 (15)
- linux 相关 (3)
- life think (3)
- 工作流管理框架 (1)
- 大数据-Hadoop (1)
最新评论
-
huih:
很不错的文章
SpringMVC+Hibernate+Spring 简单的一个整合实例 -
calm01:
学习了.
Spring <bean>标签属性 Autowire自动装配(转载) -
lizhenlzlz:
我的也是拦截不了service层
SpringAOP拦截Controller,Service实现日志管理(自定义注解的方式)(转载) -
josh_123:
讲的不错,很详细,如果quartz定时任务类采用不继承任何类的 ...
Spring,jdk定时任务的几种实现以及任务线程是串行还是并行执行(转载) -
human_coder:
你知道eclipse调试怎么可以回调吗?有时候总是调快了,不能 ...
Debug---Eclipse断点调试基础
连接抓取(Join fetching) - Hibernate通过 在SELECT语句使用OUTER JOIN
(外连接)来 获得对象的关联实例或者关联集合.
--------------------------------------------------------------------------------
查询抓取(Select fetching) - 另外发送一条 SELECT 语句抓取当前对象的关联实
体或集合。除非你显式的指定lazy="false"禁止 延迟抓取(lazy fetching),否
则只有当你真正访问关联关系的时候,才会执行第二条select语句.
--------------------------------------------------------------------------------
子查询抓取(Subselect fetching) - 另外发送一条SELECT 语句抓取在前面查询到
(或者抓取到)的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟
抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条
select语句
--------------------------------------------------------------------------------
批量抓取(Batch fetching) - 对查询抓取的优化方案, 通过指定一个主键或外键
列表,Hibernate使用单条SELECT语句获取一批对象实例或集合
这是文档中的四种抓取策略, 我用 Customer 与 Order 的一个双向一对多例子来使用四种
抓取策略看看他们的不同之处;
Customer :
view plaincopy to clipboardprint?
public class Customer {
private long id;
private String name;
private Set<Order> orders;
// getter/setter 略
}
Order :
view plaincopy to clipboardprint?
public class Order {
private long id;
private String name;
private Customer customer;
// getter/setter略
}
Order 的映射文件是不变的, 放在这 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Order" table="Order_Table">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Order_Name" />
<many-to-one name="customer"
class="Customer"
lazy="proxy"
fetch="select"
column="Cus_ID"
cascade="save-update" />
</class>
</hibernate-mapping>
连接抓取(Join fetching)
连接抓取, 使用连接抓取可以将原本需要查询两次(或多次)表的多次查询 整合到只需
要一次查询即可完成, 举个例子, 我们在初始化一个含有一对多关系的 Customer 与
Order 的时候, 会先查询 Customer 表,找到需要的 Customer , 然后再根据
Customer.id 到 Order 表中查询将Order 集合初始化, 那么在此完成初始化则需要
发送至少两条 SQL 语句, 而如果使用 join 查询的话, 其会根据需要查询的
Customer.id, 将 Customer 表与 Order 表连接起来进行查询,仅仅一条 SQL 语
句就可以将需要的数据全部查询回来;
使用连接抓取的配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="join" //---- Here
<!-- 这里关闭懒加载是为了试验明显 -->
lazy="false">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
我们使用如此查询语句 :
view plaincopy to clipboardprint?
Customer c1 = (Customer)session.get(Customer.class, 11l);
c1.getOrders().size();
Hibernate 发出的 SQL 语句为 :
view plaincopy to clipboardprint?
select
customer0_.id as id0_1_,
customer0_.Cus_Name as Cus2_0_1_,
orders1_.Cus_ID as Cus3_3_,
orders1_.id as id3_,
orders1_.id as id1_0_,
orders1_.Order_Name as Order2_1_0_,
orders1_.Cus_ID as Cus3_1_0_
from
Customer_Table customer0_
left outer join
Order_Table orders1_
on customer0_.id=orders1_.Cus_ID
where
customer0_.id=?
在此, Hibernate 使用了 left outer join 连接两个表以一条 SQL 语句将 Order 集合
给初始化了;
查询抓取(Select fetching)
查询抓取, 这种策略是在集合抓取的时候的默认策略, 即如果集合需要初始化, 那么
会重新发出一条 SQL 语句进行查询; 这是集合默认的抓取策略, 也就是我们常会出现
N+1次查询的查询策略;
配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
查询语句不变, 看看 Hibernate 发出的 SQL 语句:
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_0_,
customer0_.Cus_Name as Cus2_0_0_
from
Customer_Table customer0_
where
customer0_.id=?
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?
这就是, 重新发出一条 SQL 语句, 初始化了 Orders 集合;
子查询抓取(Subselect fetching)
子查询抓取, 另外发送一条SELECT 语句抓取在前面查询到(或者抓取到)的所有实
体对象的关联集合. 这个理解起来有点糊涂, 举个例子 : 如果你使用 Query 查询出了
4 个 Customer 实体, 由于开启了懒加载,那么他们的 Orders 都没有被初始化, 那么我
现在手动初始化一个Customer 的 Orders ,此时由于我选的是 Subselect fetching
策略,所以 Hibernate 会将前面查询到的实体对象(4 个 Customer)的关联集合(在
<set name="orders" fetch="subselect" /> )使用一条 Select 语句一次性抓取
回来, 这样减少了与数据库的交互次数, 一次将每个对象的集合都给初始化了;
[他是如何这么智能的呢? 原来,他是将上一次查询的 SQL 语句作为这一次查询的 SQL
语句的 where 子查询, 所以上次查询到几个对象,那么这次就初始化几个对象的集
合----- 正因为如此, 所以 subselect 只在 <set> 集合中出现 ];
配置文件:
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="subselect"
lazy="true">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
测试的语句有变化 :
view plaincopy to clipboardprint?
List results = session
.createQuery("From Customer c where c.id in (11,14,17,20)")
.list();
// 这里的四个 id 是我数据库中已经准备好的数据
Customer c0 = (Customer)results.get(0);
c0.getOrders().size();
这个时候再来看看 Hibernate 发出了什么样的 SQL 语句 :
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
select
customer0_.id
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
)
是不是发出的 SQL 语句形式与这个抓取策略的名字一样? Hibernate 的命名很清晰的;
批量抓取(Batch fetching)
批量抓取:"对查询抓取的优化方案,通过指定一个主键或外键列表,Hibernate使用
单条SELECT语句获取一批对象实例或集合", 也就是说其本质与 select fetching 是
一样的,只不过将一次一条的 select 策略改为一次 N 条的批量 select 查询; 举个例
子 : 还是借用 Subselect fetching 的例子,我查询出了 4 个 Customer 实体,
Orders 开启了懒加载, 所以我现在来手动初始化一个 Customer 的 orders 属性,
这种策略本质上就是 select fetching,所以如此设置 :
<set name="orders" fetch="select" batch-size="3" /> 那么此时我初始化
一个 Customer 的 orders 集合的时候, Hibernate 还是发出了一条 SQL 语句,
不过这条 SQL 与是通过指定了 Order 表中的 Customer_ID 外键列表(2个), 这个
时候 Hibernate 会以一条 SQL 语句初始化 batch-size 指定的数量的 orders 集合;
[他是如何做到的呢? 通过一个主键或外键 列表 做到的, 他将 4 个 Customer 根据
batch-size 分成了两组, 一组有三个 Customer id 值的列表,第二组只有一个,
在初始化 orders 集合的时候就是根据这两个列表来初始化的]
配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select"
lazy="true"
batch-size="3">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
在此,我关闭了集合默认的懒加载, 更有利于试验结果测试代码不变,
再来看看 Hibernate 发出的 SQL 语句 :
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
?, ?, ?
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?
原本需要四次 Select 的查询, 由于 Batch-size=3 只用了两次
就完成了;
--------------------------------------------------------------------------------
总结:
好了, 这里的四种抓取策略说明完了, 来全局看一下, 通过例子可以看出, 这四种抓取
策略并不是所有的情况都合适的, 例如, 如果我需要初始化的是一个单独的实体, 那
么 subselect 对其就没有效果,因为其本身就只需要查询一个对象, 所以 :
Join fetching , Select fetching 与 Batch-size 可以为单个实体的抓取进
行性能优化;
Join fetching , Select fetching ,Subselect fetching , Batch fetching
都可以为集合的抓取进行性能优化;
注: 这里对于单个实体可以使用 Batch-size 可能会有点疑惑, 其实在 <class > 上是
具有 Batch-size 抓取策略的; 试想, 使用一个如果是一对一关系呢? 例如 Customer
与 IdCard, 利用 HQL 查询出 4 个 Customer , 我们想一次性初始化 4 个 Customer
的 IdCard 怎么办, 设置 <class name="IdCard" batch-size="4" > , 可能我们
想设置的地方是 <one-to-one batch-size> 但是这里没有提供这个属性, 可能是因为
如果设置了不好理解吧..
(外连接)来 获得对象的关联实例或者关联集合.
--------------------------------------------------------------------------------
查询抓取(Select fetching) - 另外发送一条 SELECT 语句抓取当前对象的关联实
体或集合。除非你显式的指定lazy="false"禁止 延迟抓取(lazy fetching),否
则只有当你真正访问关联关系的时候,才会执行第二条select语句.
--------------------------------------------------------------------------------
子查询抓取(Subselect fetching) - 另外发送一条SELECT 语句抓取在前面查询到
(或者抓取到)的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟
抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条
select语句
--------------------------------------------------------------------------------
批量抓取(Batch fetching) - 对查询抓取的优化方案, 通过指定一个主键或外键
列表,Hibernate使用单条SELECT语句获取一批对象实例或集合
这是文档中的四种抓取策略, 我用 Customer 与 Order 的一个双向一对多例子来使用四种
抓取策略看看他们的不同之处;
Customer :
view plaincopy to clipboardprint?
public class Customer {
private long id;
private String name;
private Set<Order> orders;
// getter/setter 略
}
Order :
view plaincopy to clipboardprint?
public class Order {
private long id;
private String name;
private Customer customer;
// getter/setter略
}
Order 的映射文件是不变的, 放在这 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Order" table="Order_Table">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Order_Name" />
<many-to-one name="customer"
class="Customer"
lazy="proxy"
fetch="select"
column="Cus_ID"
cascade="save-update" />
</class>
</hibernate-mapping>
连接抓取(Join fetching)
连接抓取, 使用连接抓取可以将原本需要查询两次(或多次)表的多次查询 整合到只需
要一次查询即可完成, 举个例子, 我们在初始化一个含有一对多关系的 Customer 与
Order 的时候, 会先查询 Customer 表,找到需要的 Customer , 然后再根据
Customer.id 到 Order 表中查询将Order 集合初始化, 那么在此完成初始化则需要
发送至少两条 SQL 语句, 而如果使用 join 查询的话, 其会根据需要查询的
Customer.id, 将 Customer 表与 Order 表连接起来进行查询,仅仅一条 SQL 语
句就可以将需要的数据全部查询回来;
使用连接抓取的配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="join" //---- Here
<!-- 这里关闭懒加载是为了试验明显 -->
lazy="false">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
我们使用如此查询语句 :
view plaincopy to clipboardprint?
Customer c1 = (Customer)session.get(Customer.class, 11l);
c1.getOrders().size();
Hibernate 发出的 SQL 语句为 :
view plaincopy to clipboardprint?
select
customer0_.id as id0_1_,
customer0_.Cus_Name as Cus2_0_1_,
orders1_.Cus_ID as Cus3_3_,
orders1_.id as id3_,
orders1_.id as id1_0_,
orders1_.Order_Name as Order2_1_0_,
orders1_.Cus_ID as Cus3_1_0_
from
Customer_Table customer0_
left outer join
Order_Table orders1_
on customer0_.id=orders1_.Cus_ID
where
customer0_.id=?
在此, Hibernate 使用了 left outer join 连接两个表以一条 SQL 语句将 Order 集合
给初始化了;
查询抓取(Select fetching)
查询抓取, 这种策略是在集合抓取的时候的默认策略, 即如果集合需要初始化, 那么
会重新发出一条 SQL 语句进行查询; 这是集合默认的抓取策略, 也就是我们常会出现
N+1次查询的查询策略;
配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
查询语句不变, 看看 Hibernate 发出的 SQL 语句:
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_0_,
customer0_.Cus_Name as Cus2_0_0_
from
Customer_Table customer0_
where
customer0_.id=?
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?
这就是, 重新发出一条 SQL 语句, 初始化了 Orders 集合;
子查询抓取(Subselect fetching)
子查询抓取, 另外发送一条SELECT 语句抓取在前面查询到(或者抓取到)的所有实
体对象的关联集合. 这个理解起来有点糊涂, 举个例子 : 如果你使用 Query 查询出了
4 个 Customer 实体, 由于开启了懒加载,那么他们的 Orders 都没有被初始化, 那么我
现在手动初始化一个Customer 的 Orders ,此时由于我选的是 Subselect fetching
策略,所以 Hibernate 会将前面查询到的实体对象(4 个 Customer)的关联集合(在
<set name="orders" fetch="subselect" /> )使用一条 Select 语句一次性抓取
回来, 这样减少了与数据库的交互次数, 一次将每个对象的集合都给初始化了;
[他是如何这么智能的呢? 原来,他是将上一次查询的 SQL 语句作为这一次查询的 SQL
语句的 where 子查询, 所以上次查询到几个对象,那么这次就初始化几个对象的集
合----- 正因为如此, 所以 subselect 只在 <set> 集合中出现 ];
配置文件:
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="subselect"
lazy="true">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
测试的语句有变化 :
view plaincopy to clipboardprint?
List results = session
.createQuery("From Customer c where c.id in (11,14,17,20)")
.list();
// 这里的四个 id 是我数据库中已经准备好的数据
Customer c0 = (Customer)results.get(0);
c0.getOrders().size();
这个时候再来看看 Hibernate 发出了什么样的 SQL 语句 :
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
select
customer0_.id
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
)
是不是发出的 SQL 语句形式与这个抓取策略的名字一样? Hibernate 的命名很清晰的;
批量抓取(Batch fetching)
批量抓取:"对查询抓取的优化方案,通过指定一个主键或外键列表,Hibernate使用
单条SELECT语句获取一批对象实例或集合", 也就是说其本质与 select fetching 是
一样的,只不过将一次一条的 select 策略改为一次 N 条的批量 select 查询; 举个例
子 : 还是借用 Subselect fetching 的例子,我查询出了 4 个 Customer 实体,
Orders 开启了懒加载, 所以我现在来手动初始化一个 Customer 的 orders 属性,
这种策略本质上就是 select fetching,所以如此设置 :
<set name="orders" fetch="select" batch-size="3" /> 那么此时我初始化
一个 Customer 的 orders 集合的时候, Hibernate 还是发出了一条 SQL 语句,
不过这条 SQL 与是通过指定了 Order 表中的 Customer_ID 外键列表(2个), 这个
时候 Hibernate 会以一条 SQL 语句初始化 batch-size 指定的数量的 orders 集合;
[他是如何做到的呢? 通过一个主键或外键 列表 做到的, 他将 4 个 Customer 根据
batch-size 分成了两组, 一组有三个 Customer id 值的列表,第二组只有一个,
在初始化 orders 集合的时候就是根据这两个列表来初始化的]
配置文件 :
view plaincopy to clipboardprint?
<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select"
lazy="true"
batch-size="3">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
在此,我关闭了集合默认的懒加载, 更有利于试验结果测试代码不变,
再来看看 Hibernate 发出的 SQL 语句 :
view plaincopy to clipboardprint?
Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
?, ?, ?
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?
原本需要四次 Select 的查询, 由于 Batch-size=3 只用了两次
就完成了;
--------------------------------------------------------------------------------
总结:
好了, 这里的四种抓取策略说明完了, 来全局看一下, 通过例子可以看出, 这四种抓取
策略并不是所有的情况都合适的, 例如, 如果我需要初始化的是一个单独的实体, 那
么 subselect 对其就没有效果,因为其本身就只需要查询一个对象, 所以 :
Join fetching , Select fetching 与 Batch-size 可以为单个实体的抓取进
行性能优化;
Join fetching , Select fetching ,Subselect fetching , Batch fetching
都可以为集合的抓取进行性能优化;
注: 这里对于单个实体可以使用 Batch-size 可能会有点疑惑, 其实在 <class > 上是
具有 Batch-size 抓取策略的; 试想, 使用一个如果是一对一关系呢? 例如 Customer
与 IdCard, 利用 HQL 查询出 4 个 Customer , 我们想一次性初始化 4 个 Customer
的 IdCard 怎么办, 设置 <class name="IdCard" batch-size="4" > , 可能我们
想设置的地方是 <one-to-one batch-size> 但是这里没有提供这个属性, 可能是因为
如果设置了不好理解吧..
发表评论
-
教你使用Hibernate的QBC查询(转载)
2015-12-18 17:19 4223转载自:http://developer.51cto.com ... -
hibernatesynchronizer3开发工具的使用方法
2014-11-24 14:35 25931. hibernatesynchronizer3可以帮助 ... -
Hibernate锁机制(悲观锁,乐观锁)
2014-09-24 17:16 2096锁(locking) 业务逻辑的实现过程中,往往需要保证 ... -
六种方式实现hibernate查询,及IDE推荐 (转载)
2014-07-16 18:13 1254hibernate查询的6种方法。分别是HQL查询,对象 ... -
SpringMVC+Hibernate+Spring 简单的一个整合实例
2014-07-04 16:14 87782SpringMVC又一个漂亮的web框架,他与Struts2 ... -
Struts2、hibernate和spring下载,整合所需jar包
2014-07-04 16:00 4459ssh三个框架各自所有版本下载地址如下 Struts f ... -
Hibernate Criteria的 Criterion,Projection,Restrictions等条件设置
2014-04-01 16:46 38024在查询方法设计上可以灵活的根据Criteria的特点来方便 ... -
Hibernate的Example示例查询
2013-07-29 17:32 4016org.hibernate.criterion.Ex ... -
Spring与Hibernate集成中的session问题
2013-04-15 15:53 31621.通过getSession()方法 ... -
剖析Hibernate主键生成几种常用方式
2012-12-05 20:01 13221.assigned: 主键由外部程序负责生成,无需H ... -
正确理解Hibernate Inverse (转)
2012-12-05 11:02 1369通过Hibernate Inverse的设 ... -
Hibernate中session.getconnection()的替代方法
2012-08-27 16:39 51752010-04-15 10:21 Hibernate ... -
Hql总结 查询结果动态组装成List(map),List(bean),List(list),List(set)等格式(转)
2012-08-17 15:51 73301.//查询整个对象String hql="from ... -
sql和hql中join语句区别,以及hibernate中内连接,迫切内连接,左外连接,迫切左外连接,右外连接的区别(合集)
2012-07-24 17:39 3215第一:sql和hql中join语 ... -
Hibernate_HQL--实体、属性查询,参数绑定,引用查询(随时温习一遍)
2012-07-05 17:52 15928是Hibernate官方推荐的查询模式,比Criteria功能 ... -
hibernate里createSQLQuery的addEntity()和setResultTransformer()方法
2012-06-21 10:55 565551. 使用SQLQuery对原生SQL查询执行的控制是通过S ... -
hibernate的session.connection被session.dowork()替代
2012-06-14 10:22 4089Hibernate3.3.2版本中getSessi ... -
Hibernate继承映射多态的详解
2012-06-05 17:36 1956在面向对象的程序领域中,类与类之间是有继承关系的,例如Java ... -
hibernateTemplate session关闭
2012-04-18 14:53 37771.虽然继承了HibernateDaoSupport这个类,但 ... -
No Hibernate Session bound to thread, and configuration does not allow creation
2012-04-18 10:57 2180用SessionFactory.getCurrentSessi ...
相关推荐
为了解决这个问题,Hibernate提供了几种抓取策略,包括批量抓取和预加载。 批量抓取允许我们在一次查询中获取多个关联对象,而不是逐个加载。例如,如果我们有一个`User`实体,每个用户都有多个`Order`,我们可以...
今天我们将深入探讨"day36 06-Hibernate抓取策略",特别是针对set集合的抓取策略。在阅读这篇博客文章(链接:https://364232252.iteye.com/blog/2368811)后,我们将了解到如何优化数据加载,以避免N+1查询问题,...
在Java的持久化框架Hibernate中,数据访问优化是至关重要的,而抓取策略(Fetch Strategy)和懒加载(Lazy Loading)则是实现这一目标的关键技术。本文将深入探讨这两个概念,并通过具体的案例进行分析。 首先,让...
今天我们要讨论的是Hibernate框架中的一个关键概念——抓取策略,特别是针对"many-to-one"关系的抓取策略。这篇博客将深入剖析这个主题,帮助你更好地理解和应用Hibernate。 Hibernate是Java领域中最流行的对象关系...
hibernate3数据检索、抓取策略 、 注解的使用
子查询抓取策略为集合代理提供了一种特殊的抓取方式,它不使用外连接,而是为每个实体对象单独发送一条SELECT语句来抓取关联集合。这种方式在某些情况下能更精细地控制数据加载,但可能导致较多的数据库交互。 ### ...
关于Hibernate的各种主键生成策略与配置详解
在Java的持久化框架Hibernate中,主键生成策略是一个至关重要的概念,它决定了数据库表中主键值如何自动生成。主键通常是表中唯一标识记录的一列,对于数据的完整性和一致性至关重要。以下是对Hibernate中主键生成...
本文将详细介绍Hibernate提供的几种常见的主键生成策略,包括assigned、increment、identity以及native等,并探讨它们各自的适用场景及优缺点。 #### 二、主键概述 主键可以分为两种类型:自然主键和代理主键。 1....
首先,ID生成策略是Hibernate为了保证每个实体对象在数据库中的唯一性而设计的一种机制。它定义了如何生成和分配给新创建的对象一个唯一的标识符(ID)。在Hibernate中,ID生成策略有多种类型,每种都有其特定的适用...
这两种策略生成基于UUID的128位二进制或16进制字符串,确保全局唯一,适用于分布式系统。 8. **foreign**策略: 主键的值来源于关联的另一个实体的主键。 9. **native**策略: Hibernate会选择最适合当前数据库...
Hibernate继承映射是将Java类的继承关系映射到数据库表的一种策略,使得对象模型的复杂性能够平滑地转化为关系数据库模型。本篇将详细介绍Hibernate继承映射的第一种策略——每棵类继承树对应一张表,即单一表继承...
总结,"Hibernate主键策略-sequence"是利用数据库序列来生成主键的一种方式,具有性能优势但可能涉及跨应用的同步问题。了解和正确使用这一策略,能够帮助开发者更好地设计和实现数据持久化的系统。
本篇文章主要探讨了Hibernate中的多表查询和抓取策略,这对于理解如何高效地从数据库获取数据至关重要。 1. **Hibernate中的多表查询** Hibernate支持多种多表查询方式,类似于SQL中的连接查询: - **交叉连接*...
Hibernate通过多种继承映射策略解决了这一问题,其中“每个具体类一张表”是最为直观的一种。这种方式适用于子类较多,且子类之间差异较大的场景。 1. **基本概念** - **实体类**:在Hibernate中,被映射到数据库...
本文将详细探讨“Hibernate继承映射的第一种策略:每个类对应一张表”的概念、实现方式以及其优缺点。 首先,我们需要理解Hibernate继承映射的基本策略。在面向对象编程中,类继承是常见的代码复用手段,但在数据库...
通过以上内容可以看出,在Oracle环境下使用Hibernate的“native”策略生成主键是一种高效且灵活的方式。只需要在映射文件中简单地指定`<generator class="native"></generator>`即可实现。同时,还需要注意数据库中...