- 浏览: 656951 次
- 性别:
- 来自: 杭州
文章分类
最新评论
-
HkEndless:
不好意思,请问这确定是回调机制吗。你的例子中只是将接口的实现类 ...
Spring CallBack回调机制介绍 -
hanmiao:
写的真乱啊,完全不知所云...
Java如何调用可执行文件和批处理命令 -
junia_1:
junia_1 写道 shock: ...
为什么要使用EJB -
junia_1:
shock:
为什么要使用EJB -
coollifer:
不错
SQL Server数据导入到Oracle中的方法
hibernate lazy策略可以使用在:
* <class>标签上,可以取值:true/false ,在hibernate3以上版本,默认是true
* <property>标签上,可以取值:true/false需要类增强工具
* <set><list>标签上,可以取值:true/false/extra
* <one-to-one><many-to-one>单端关联上,可以取值:false/proxy/no-proxy
lazy概念:只有真正使用该对象时,才会创建,对于hibernate而言,正真使用的时候才会发出sql
hibernate支持lazy策略只有在session打开状态下有效
=====================================================
1. <class>标签上:
hbm
group.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
">
<hibernate-mapping package="com.model">
<class name="Group" table="group5" lazy="true" > //lazy,默认true,可不写
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" length="50" type="java.lang.String" />
</class>
</hibernate-mapping>
测试用例:
public class LazyTest extends TestCase {
public void testLoad1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Group g2 = (Group) session.load(Group.class, 1); //还没发出sql,lazy起延迟作用,若lazy=false,则发出sql
// Group g2 = (Group) session.get(Group.class, 1); //不支持lazy
System.out.println("group.id=" + g2.getId()); //还没发出sql,
System.out.println("group.name=" + g2.getName()); //发出sql
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
//System.out.println("group.name=" + g2.getName()); //hibernate支持lazy策略只有在session打开状态下有效,所以此出Exception
}
}
<class>标签上的lazy特性只对普通属性起作用
<class>标签上的lazy不会影响到单端关联上的lazy特性
=========================================
2.<set><list>标签上 ,可以取值:true/false/extra,默认是true
hbm.xml
Classes.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
">
<hibernate-mapping package="com.zd.model">
<class name="Classes" table="classes" >
<id name="id" column="id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" column="name" type="java.lang.String" />
<set name="students" lazy="true"> //可不配lazy,因默认是true
<key column="class_id" />
<one-to-many class="com.zd.model.Student" />
</set>
</class>
</hibernate-mapping>
测试用例:
public void testLoad1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Classes c = (Classes) session.load(Classes.class, new Integer(2)); //没有sql
System.out.println("Class.name=" + c.getName());//发出一条sql,但不查 set
Set stuSet = c.getStudents();//没有发出查询sql,不是统计sql
//System.out.println(stuSet.size());//发出查询sqlsql
if(stuSet != null && !stuSet.isEmpty()){//发出查询sqlsql
for(Iterator it = stuSet.iterator(); it.hasNext();){
Student s = (Student) it.next();//若没有.size(),isEmpty(),就在这边发出sql
System.out.println("student.name=" + s.getName());
}
}
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Class.name=Java Class
Hibernate: select students0_.class_id as
class3_1_, students0_.id as id1_, students0_.id as id1_0_,
students0_.name as name1_0_, students0_.class_id as class3_1_0_ from
student students0_ where students0_.class_id=?
2
student.name=z3
student.name=l4
若<set name="students" lazy="false"> //不延迟加载, 马上加载
则在
System.out.println("Class.name=" + c.getName());// 就发出2条查询语句了。
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Hibernate: select students0_.class_id as
class3_1_, students0_.id as id1_, students0_.id as id1_0_,
students0_.name as name1_0_, students0_.class_id as class3_1_0_ from
student students0_ where students0_.class_id=?
Class.name=Java Class
student.name=l4
student.name=z3
若<set name="students" lazy="extra"> //和true差不多,只是在写set.size()时,发出selcet count的sql语句,比true好一些。
测试用例:
public void testLoad1(){
Session session = null;
Transaction ta = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
Classes c = (Classes) session.load(Classes.class, new Integer(2));
System.out.println("Class.name=" + c.getName());
Set stuSet = c.getStudents();
System.out.println(stuSet.size());
if(stuSet != null && !stuSet.isEmpty()){
for(Iterator it = stuSet.iterator(); it.hasNext();){
Student s = (Student) it.next();
System.out.println("student.name=" + s.getName());
}
}
ta.commit();
}catch(Exception e){
e.printStackTrace();
if(ta != null){
ta.rollback();
}
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Class.name=Java Class
Hibernate: select count(id) from student where class_id =?
2
Hibernate: select students0_.class_id as class3_1_, students0_.id as
id1_, students0_.id as id1_0_, students0_.name as name1_0_,
students0_.class_id as class3_1_0_ from student students0_ where
students0_.class_id=?
student.name=z3
student.name=l4
===============================================
3.<one-to-one><many-to-one>单端关联 上,可以取值:false/proxy/no-proxy,默认是proxy(代理),延迟加载作用
hbm.xml
User.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
">
<hibernate-mapping package="com.model">
<class name="User" table="user1" >
<id name="id" column="user_id" type="java.lang.Integer">
<generator class="native" />
</id>
<property name="name" length="50" type="java.lang.String" />
<many-to-one name="group" column="group_id" lazy="proxy
"></many-to-one> //可不写,默认是proxy
</class>
</hibernate-mapping>
测试用例:
public void testGet1(){
Session session = null;
Transaction ta = null;
User user = null;
try{
session = HibernateUtil.getSession();
ta = session.beginTransaction();
user = (User)session.load(User.class, new Integer(3)); //无sql
System.out.println("user.name=" + user.getName()); //有一条sql
Group group = user.getGroup();//无sql
System.out.println("group.name=" + group.getName());//有一条sql
ta.commit();
}catch(Exception e){
e.printStackTrace();
ta.rollback();
}finally{
//关闭session, user变为detached离线对象
HibernateUtil.closeSession(session);
}
}
若<many-to-one name="group" column="group_id" lazy="false "></many-to-one>
不延迟加载,立即加载,
System.out.println("user.name=" + user.getName()); //发出2条sql语句
==========================================
hibernate 中的 lazy="proxy" 和 lazy="no-proxy" 到底是什么意思?
举个例子吧:
Child <- many-to-one ->Parent
class Child {
private Parent parent;
public Parent getParent (){
return this.parent;//访问了实例变量
}
}
class Parent {
private String name;
public String getName(){
return this.name;//访问了实例变量
}
public void f(){
System.out.println("invokeing f()");//没有访问实例变量
}
}
如果
many-to-one
的lazy设为proxy,当child.getParent().getName()或child.getParent().f()时,parent都
会被抓取,若设为no-proxy,调用child.getParent().f()时,parent是不会被抓取的,同时这种方式需要编译时字节码增强
,否则和proxy没区别。
(注:测试发现真和proxy一样,不能理解 编译时字节码增强,要再哪修改,或是什么条件?)
如果设置了 lazy="proxy",就 ,当通过 child 来调用其关联的 parent, 如果调用 parent 类中定义的任何方法,都会抓取 parent (所谓的抓取是不是就是从数据库查询,执行一次 select ?)
如果设置了 lazy="no-proxy" ,只有调用 parent 类中牵涉到类变量的方法,才会抓取 parent,否则,就像调用 f(), 不会抓取 parent
."编译时字节码增强" 是什么意思?
"字节码增强"分编译期和运行期2种,编译期是修改java类编译后的class字节码文件,在上面附加“增强”操作。(不明白why?)
================
lazy (可选 - 默认为 proxy): 默认情况下,单点关联是经过代理的。lazy="no-proxy"指定此属性应该在实例变量第一次被访问时应该延迟抓取(fetche lazily)(需要运行时字节码的增强)。 lazy="false"指定此关联总是被预先抓取。注意,如果constrained="false", 不可能使用代理,Hibernate会采取预先抓取!
发表评论
-
hibernate Restrictions用法 MatchMode.ANYWHERE
2012-07-14 15:50 3945方法 说明 Res ... -
hibernate3 大批量更新/删除数据 (update/delete)
2011-11-10 12:15 1366Hibernate3.0 采用新的基 ... -
一些关于Hibernate延迟加载的误区
2011-09-12 23:13 887首先是第一个误区:延迟加载只能作用于关联实体 看到这个是 ... -
org.hibernate.PropertyAccessException: IllegalArgumentException occurred calling
2011-08-12 19:17 1246Hi I am facing a problem wit ... -
Criteria Condition: Match Mode End
2011-07-02 11:05 984//////////////////////////// ... -
Criteria: Group By Criteria
2011-07-02 11:03 1333/////////////////////////////// ... -
Query Criteria Equal
2011-07-02 11:02 893/////////////////////////////// ... -
Criteria: Order
2011-07-02 10:59 768//////////////////////////// ... -
Criteria: Associations Sorting Criteria
2011-07-02 10:57 913//////////////////////////// ... -
hibernate的Query有没有setResultTransformer这个方法
2011-07-01 23:24 3083可以对原生SQL 查询使用ResultTransformer。 ... -
Hibernate中一级缓存、二级缓存及查询缓存的技术性总结
2011-06-21 17:31 1233一、 一级缓存 1. ... -
hibernate 保存 oracle 10g大数据字段
2011-06-14 04:01 1448Java代码 要点如下: ... -
Hibernate 错误原因总结
2011-06-14 00:10 14281、错误: object references an unsa ... -
MappingException提示Association references unmapped class错误的解决方法
2011-06-12 17:09 10出现如下错误信息时 Caused by: org.hibe ... -
Hibernate一对多关联映射的配置及其级联删除问题
2011-06-12 17:07 9首先举一个简单的一对多双向关联的配置: 一的一端:Quest ... -
Hibernate多对一关联映射原理、映射方法和数据的保存
2011-06-12 17:06 13Hibernate的多对一关联映射实现的基本原理就是: 在多 ... -
Hibernate一对多单向关联和双向关联映射方法及其优缺点
2011-06-12 17:05 11一对多关联映射和多对一关联映射实现的基本原理都是一样的,既是在 ... -
inverse = “true” example and explanation
2011-06-11 22:18 1119In Hibernate, only the “relatio ... -
ibatis和hibernate区别
2011-04-13 17:34 827ibatis:sql需要自己写 hibe ... -
Hibernate StackOverFlowError 异常出现的原因
2011-04-13 16:51 1275引起StackOverFlowError异常的一般是因为在程序 ...
相关推荐
在Java的持久化框架Hibernate中,懒加载(Lazy Loading)是一种重要的优化策略,它的核心思想是“延迟加载”或“按需加载”。默认情况下,当一个实体被加载时,并不会立即加载其关联的对象或集合,而是在真正需要...
### Hibernate延迟加载深入剖析 #### 一、概述 在现代软件开发中,特别是与数据库交互的应用场景下,Hibernate作为一款流行的Java持久层框架,提供了多种高效处理数据的技术。其中,延迟加载(Lazy Loading)是一...
在Java的持久化框架Hibernate中,延迟加载(Lazy Load)是一项重要的优化策略,其核心目标是提高系统性能,减少内存占用,避免不必要的数据库交互。延迟加载允许我们在需要使用数据时才从数据库中加载,而不是在加载...
在Hibernate中启用实体对象的延迟加载,需在实体的映射配置文件中设置`lazy="true"`属性。例如: ```xml <hibernate-mapping> <class name="net.ftng.entity.user" table="user" lazy="true"> ... </hibernate-...
### Hibernate延迟加载以及利用Spring #### 一、Hibernate延迟加载概念与原理 在理解Hibernate的延迟加载机制之前,我们首先需要了解什么是延迟加载。延迟加载(Lazy Loading)是一种设计模式,其核心思想是在真正...
要在Hibernate中启用实体对象的延迟加载,需要在映射文件中为相应的类添加`lazy="true"`属性,例如: ```xml <class name="com.neusoft.entity.User" table="user" lazy="true"> ... ``` **工作原理:** 当执行...
在开发Flex与Hibernate集成的应用时,延迟加载(Lazy Loading)是一个常见的挑战,因为Flex客户端无法直接理解和处理Hibernate的延迟加载机制。延迟加载是一种优化策略,它允许关联的对象在真正需要时才被加载,而...
懒加载是一种延迟加载策略,只在真正需要时才加载关联的数据,以减少内存消耗和提高响应速度。 Gilead,全称为Hibernate for Flex,是用于Flex和Hibernate之间的数据绑定工具,它提供了一种在Flex客户端和Hibernate...
在 Hibernate 框架中,延迟加载(Lazy Loading)是一种优化数据访问性能的重要技术。它允许我们只在真正需要数据时才从数据库加载,避免一次性加载大量数据导致的内存消耗和性能瓶颈。当我们处理与实体相关的集合...
Hibernate的延迟加载(Lazy Loading)和懒加载机制(Lazy Initialization)是优化ORM框架性能的重要策略。这个机制的主要目的是提高程序的效率,减少不必要的数据库交互,只在真正需要数据时才去加载它们。以下是对...
在Java的持久化框架Hibernate中,延迟加载(Lazy Loading)是一种优化数据库访问性能的技术。它允许我们在需要时才加载关联的对象,而不是在初始查询时就一次性加载所有数据。这有助于减少不必要的数据库交互,从而...
Hibernate作为Java领域中的一个强大的对象关系映射框架,提供了许多优化数据库操作的策略,其中之一便是延迟加载(Lazy Loading)。延迟加载机制旨在减少不必要的性能消耗,只在真正需要数据时才执行加载操作。本文...
Hibernate延迟加载是ORM框架Hibernate中的一个重要特性,它旨在提高应用程序的性能和效率。延迟加载(Lazy Loading)策略允许我们仅在需要访问一个对象或其属性时才从数据库加载它们,而不是在初始加载实体时就一次...
而延迟加载(Lazy Loading),作为Hibernate提供的一种优化策略,旨在减少数据库访问,提高应用程序的性能。 #### 延迟加载与非延迟加载对比 - **非延迟加载**:在非延迟加载中,当读取一个对象时,与该对象相关的...
为了提高应用程序性能,Hibernate 提供了多种优化手段,其中“延迟加载(Lazy Loading)”是一种非常重要的性能优化技术。本文主要探讨 Hibernate 中的延迟加载机制及其具体应用场景。 #### 二、基本概念 延迟加载...
在 Hibernate 框架中,延迟加载(Lazy Loading)是一种非常重要的优化技术,它能够有效地减少数据库查询次数,提高应用性能。通常,在多对多或者一对多的关系中,延迟加载能够避免 N+1 查询问题。本文将详细探讨 ...