- 浏览: 111013 次
- 性别:
- 来自: 上海
文章分类
最新评论
lazy策略可以使用在:
* <class>标签上,可以取值:true/false
* <property>标签上,可以取值:true/false需要类增强工具
* <set><list>标签上,可以取值:true/false/extra
* <one-to-one><many-to-one>单端关联上,可以取值:false/proxy/noproxy
lazy概念:只有真正使用该对象时,才会创建,对于hibernate而言,正真使用时才会发出sql
注意:hibernate支持lazy策略只有在session打开关态下有效
<class>标签上的lazy特性只对普通属性起作用,不会影响到集合上的lazy特性
<class>标签上的lazy特性只对普通属性起作用,不会影响到单端关联上的lazy特性
在jsp中使用OpenSessionInview模式,一般采用filter实现
lazy策略在<class>上
//设置<class>标签上的lazy="true",也就是默认配置
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发sql
Group g=(Group)session.load(Group.class, 1);
//不会发sql
System.out.println(g.getId());
//会发sql
System.out.println(g.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testload2(){
Session session=null;
Group g=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发sql
g=(Group)session.load(Group.class, 1);
//不会发sql
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
//不能正确输出,抛出lazy初始化lazyInitializationException异常,因为session已经关闭
//hibernate支持lazy策略只有在session打开关态下有效
System.out.println(g.getName());
}
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发sql
Group g=(Group)session.load(Group.class, 1);
//不会发sql
System.out.println(g.getId());
//会发sql
System.out.println(g.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testload2(){
Session session=null;
Group g=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发sql
g=(Group)session.load(Group.class, 1);
//不会发sql
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
//不能正确输出,抛出lazy初始化lazyInitializationException异常,因为session已经关闭
//hibernate支持lazy策略只有在session打开关态下有效
System.out.println(g.getName());
}
lazy策略在<set><list>上
<class>标签上的lazy特性只对普通属性起作用,不会影响到集合上的lazy特性
//保持lazy是默认配置
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//会发出sql,发出查询全部数据的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<class>标签上的lazy="false"
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//不会发出sql
System.out.println(classes.getName());
//不会发出sql,不会影响集合
Set students=classes.getStudents();
//会发出sql,发出查询全部数据的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置集合上的lazy="false",其他全为默认
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql,会发出两条sql分别加载classes和Student
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//不会发出sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置集合上的lazy="extra",其他全为默认(比智能,基本与lazy="true"相同)
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//会发出sql,发出一条比较智能的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//会发出sql,发出查询全部数据的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<class>标签上的lazy="false"
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//不会发出sql
System.out.println(classes.getName());
//不会发出sql,不会影响集合
Set students=classes.getStudents();
//会发出sql,发出查询全部数据的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置集合上的lazy="false",其他全为默认
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql,会发出两条sql分别加载classes和Student
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//不会发出sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置集合上的lazy="extra",其他全为默认(比智能,基本与lazy="true"相同)
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
Classes classes=(Classes)session.load(Classes.class, 3);
//会发出sql
System.out.println(classes.getName());
//不会发出sql
Set students=classes.getStudents();
//会发出sql,发出一条比较智能的sql
System.out.println(students.size());
session.getTransaction().commit();
}catch(Exception e){
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
lazy策略在<one-to-one><many-to-one>单端关联上
可以取值:false/proxy/noproxy,默认为proxy,noproxy为不用代理,使用自解码,要使用增强工具
//所有lazy全为默认
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
User user=(User)session.load(User.class, 3);
//会发出sql
System.out.println(user.getName());
//不会发出sql
Group group=user.getGroup();
//会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<many-to-one>的lazy="false",其他全为默认,效果同集合
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
User user=(User)session.load(User.class, 3);
//会发出sql,会发出两条sql分别加载Group和User
System.out.println(user.getName());
//不会发出sql
Group group=user.getGroup();
//不会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<class>标签上的lazy="false",其他全默认,效果同集合
<class>标签上的lazy特性只对普通属性起作用,不会影响到<many-to-one>的lazy特性
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//会发出sql
User user=(User)session.load(User.class, 3);
//不会发出sql
System.out.println(user.getName());
//不会发出sql,不会影响到<many-to-one>
Group group=user.getGroup();
//会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e)Codeh
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
User user=(User)session.load(User.class, 3);
//会发出sql
System.out.println(user.getName());
//不会发出sql
Group group=user.getGroup();
//会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<many-to-one>的lazy="false",其他全为默认,效果同集合
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql
User user=(User)session.load(User.class, 3);
//会发出sql,会发出两条sql分别加载Group和User
System.out.println(user.getName());
//不会发出sql
Group group=user.getGroup();
//不会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
//设置<class>标签上的lazy="false",其他全默认,效果同集合
<class>标签上的lazy特性只对普通属性起作用,不会影响到<many-to-one>的lazy特性
public void testload1(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//会发出sql
User user=(User)session.load(User.class, 3);
//不会发出sql
System.out.println(user.getName());
//不会发出sql,不会影响到<many-to-one>
Group group=user.getGroup();
//会发出sql
System.out.println(group.getName());
session.getTransaction().commit();
}catch(Exception e)Codeh
发表评论
-
hibernate基础-初步
2009-11-03 15:26 608类拟框架:Apache OJB,JDO,Toplink,EJB ... -
hibernate基础-基本映谢标签和属性
2009-11-03 15:35 644hibernate基本映射 实体类------>表 实体 ... -
hibernate基础-映射关系(多对一I一对一)
2009-11-03 15:53 480多对一关联映射 many-to-one关联映射本质: * ... -
hibernate基础-映射关系(一对多I多对多).
2009-11-03 16:04 572一对多关联映射(one-to-many) 一对多关联映射利用了 ... -
hiberante基础-继承映射
2009-11-03 16:15 730继承映射的三种策略: * 单表继承,每棵类继承树使用一个表 ... -
hibernate基础-其他映射
2009-11-03 16:17 621set、list、array、map Collection: ... -
hibernate基础-自关联映射
2009-11-03 16:19 7161 class Node: private int id;pr ... -
hibernate基础-Component+[联合]映象
2009-11-03 16:22 483Component映射(值对象映射) 在hibernate中, ... -
hibernate基础-fetch抓取
2009-11-03 16:34 571抓取策略(单端代理的批量抓取) 1 保持默认,也就是fetch ... -
hibernate基础-Session_Flush
2009-11-03 16:37 669session flush测试: session ... -
hibernate基础-悲观[乐观]锁
2009-11-03 16:40 469悲观锁 悲观锁的实现,通常依赖于数据库机制,在整个过程中将数据 ... -
hiberante基出-缓存
2009-11-03 16:49 479一级缓存 * 一级缓存是缓存实体对象的 * 如果管理一 ... -
hibernate基础-HQL
2009-11-03 17:14 518在hql中关键字不区分大小写,但是属性和类名区分大不写简单属性 ... -
hibernate基础-HibernateTemplate
2009-11-03 17:20 5271 ,void delete ( Object entity ... -
[导入]Hibernate 深入研究之 Criteria
2009-11-03 17:35 550文章来源:http://www.cnblogs.com/ ... -
DetachedCriteria
2009-11-03 17:41 639org.hibernate.criterion.Detache ... -
Restrictions
2009-11-03 17:46 700HQL运算符 ... -
hibernate.cfg.xml
2009-11-03 17:56 586<?xml version="1.0&quo ... -
由映射文件生成表
2009-11-03 17:57 532import org.hibernate.cfg.Confi ... -
JNDI连接池
2009-11-29 21:19 697管理连接对象 Modle:biz,dao,entity 数据源 ...
相关推荐
5.1.2 Hibernate访问持久化类属性的策略 5.1.3 在持久化类的访问方法中加入程序逻辑 5.1.4 设置派生属性 5.1.5 控制insert和update语句 5.2 处理SQL引用标识符 5.3 创建命名策略 5.4 设置数据库Schema...
19.1.7. 使用延迟属性抓取(Using lazy property fetching) 19.2. 二级缓存(The Second Level Cache) 19.2.1. 缓存映射(Cache mappings) 19.2.2. 策略:只读缓存(Strategy: read only) 19.2.3. 策略:读/...
19.1.7. 使用延迟属性抓取(Using lazy property fetching) 19.2. 二级缓存(The Second Level Cache) 19.2.1. 缓存映射(Cache mappings) 19.2.2. 策略:只读缓存(Strategy: read only) 19.2.3. 策略:读/...
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.5. composite-id 5.1.6. 鉴别器...
19.1.7. 使用延迟属性抓取(Using lazy property fetching) 19.2. 二级缓存(The Second Level Cache) 19.2.1. 缓存映射(Cache mappings) 19.2.2. 策略:只读缓存(Strategy: read only) 19.2.3. 策略:读/...
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.1.1. EntityResolver 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.4.1. Generator 5.1.4.2. 高...
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.5. composite-id 5.1.6. 鉴别器...
延迟初始化(延迟加载)(Lazy Initialization) 6.6. 集合排序(Sorted Collections) 6.7. 使用<idbag><br>6.8. 双向关联(Bidirectional Associations) 6.9. 三重关联(Ternary Associations) 6.10....
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.4.1. Generator 5.1.4.2. 高/低位算法(Hi/Lo ...
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.4.1. Generator 5.1.4.2. 高/低位算法(Hi/Lo ...
6. 对象/关系数据库映射基础(Basic O/R Mapping) 6.1. 映射定义(Mapping declaration) 6.1.1. Doctype 6.1.2. hibernate-mapping 6.1.3. class 6.1.4. id 6.1.4.1. Generator 6.1.4.2. 高/低位算法(Hi/Lo ...
5.1.2 Hibernate访问持久化类属性的策略 5.1.3 在持久化类的访问方法中加入程序逻辑 5.1.4 设置派生属性 5.1.5 控制insert和update语句 5.2 处理SQL引用标识符 5.3 创建命名策略 5.4 设置数据库Schema...
5.1.2 Hibernate访问持久化类属性的策略 5.1.3 在持久化类的访问方法中加入程序逻辑 5.1.4 设置派生属性 5.1.5 控制insert和update语句 5.2 处理SQL引用标识符 5.3 创建命名策略 5.4 设置数据库Schema...
5.1.2 Hibernate访问持久化类属性的策略 5.1.3 在持久化类的访问方法中加入程序逻辑 5.1.4 设置派生属性 5.1.5 控制insert和update语句 5.2 处理SQL引用标识符 5.3 创建命名策略 5.4 设置数据库Schema...
延迟初始化(延迟加载)(Lazy Initialization) 6.6. 集合排序(Sorted Collections) 6.7. 使用<idbag><br>6.8. 双向关联(Bidirectional Associations) 6.9. 三重关联(Ternary Associations) 6.10....
6. 对象/关系数据库映射基础(Basic O/R Mapping) 6.1. 映射定义(Mapping declaration) 6.1.1. Doctype 6.1.2. hibernate-mapping 6.1.3. class 6.1.4. id 6.1.4.1. Generator 6.1.4.2. 高/低位算法(Hi/Lo ...
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.4.1. Generator 5.1.4.2. 高/低位算法(Hi/Lo ...
HQL的多表检索 事务及隔离级别 HQL优化 抓取策略
5. 对象/关系数据库映射基础(Basic O/R Mapping) 5.1. 映射定义(Mapping declaration) 5.1.1. Doctype 5.1.1.1. EntityResolver 5.1.2. hibernate-mapping 5.1.3. class 5.1.4. id 5.1.4.1. Generator 5.1.4.2. 高...