- 浏览: 162625 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
jiangyeqt:
好好的温习了一遍,讲的非常的到位
Session的原理 -
JAVA静静:
这是什么啊?有没有源码?看不懂诶!
开源框架Pushlet入门 -
colinzhy:
讲的很深刻,学习了
Session的原理 -
昔雪似花:
...
Map-iterator -
不相信眼泪:
恩,很好,多谢
.scc文件是做什么用的?
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
发表评论
-
Java通用数据访问层Fastser-DAL推荐
2014-12-29 10:20 5620本着不重复造轮子的原则,基于mybatis、spring ... -
hibernate基础-初步
2009-11-03 15:26 717类拟框架:Apache OJB,JDO,Toplink,EJB ... -
hibernate基础-基本映谢标签和属性
2009-11-03 15:35 784hibernate基本映射 实体类------>表 实体 ... -
hibernate基础-映射关系(多对一I一对一)
2009-11-03 15:53 717多对一关联映射 many-to-one关联映射本质: * ... -
hibernate基础-映射关系(一对多I多对多).
2009-11-03 16:04 676一对多关联映射(one-to-many) 一对多关联映射利用了 ... -
hiberante基础-继承映射
2009-11-03 16:15 627继承映射的三种策略: * 单表继承,每棵类继承树使用一个表 ... -
hibernate基础-其他映射
2009-11-03 16:17 653set、list、array、map Collection: ... -
hibernate基础-自关联映射
2009-11-03 16:19 6581 class Node: private int id;pr ... -
hibernate基础-Component+[联合]映象
2009-11-03 16:22 605Component映射(值对象映射) 在hibernate中, ... -
hibernate基础-fetch抓取
2009-11-03 16:34 698抓取策略(单端代理的批量抓取) 1 保持默认,也就是fetch ... -
hibernate基础-Session_Flush
2009-11-03 16:37 836session flush测试: session ... -
hibernate基础-悲观[乐观]锁
2009-11-03 16:40 690悲观锁 悲观锁的实现,通常依赖于数据库机制,在整个过程中将数据 ... -
hiberante基出-缓存
2009-11-03 16:49 750一级缓存 * 一级缓存是缓存实体对象的 * 如果管理一 ... -
hibernate基础-HQL
2009-11-03 17:14 789在hql中关键字不区分大小写,但是属性和类名区分大不写简单属性 ... -
hibernate基础-HibernateTemplate
2009-11-03 17:20 7561 ,void delete ( Object entity ... -
[导入]Hibernate 深入研究之 Criteria
2009-11-03 17:35 677文章来源:http://www.cnblogs.com/ ... -
DetachedCriteria
2009-11-03 17:41 948org.hibernate.criterion.Detache ... -
Restrictions
2009-11-03 17:46 844HQL运算符 ... -
hibernate.cfg.xml
2009-11-03 17:56 658<?xml version="1.0&quo ... -
由映射文件生成表
2009-11-03 17:57 720import org.hibernate.cfg.Confi ...
相关推荐
总结,Hibernate的one-to-many和many-to-one关系映射是数据库对象关联的基础,理解和熟练掌握它们能帮助开发者更高效地设计和实现Java持久化层。通过合理的配置和实践,可以构建出高性能、易于维护的数据访问层。
【Hibernate入门 - 基础配置】 在Java开发中,Hibernate是一个非常重要的对象关系映射(ORM)框架,它极大地简化了数据库操作。本文将深入介绍Hibernate的基础配置和功能,帮助初学者快速入门。 一、ORM框架与...
10. **性能优化**:Hibernate提供了多种优化手段,如延迟加载(Lazy Loading)、批处理(Batch Processing)、缓存策略等,以提高系统性能。 这个压缩包中的"required"目录可能包含了Hibernate运行所必需的JAR文件...
- **延迟加载**:通过 FetchType.LAZY 设置关联对象的加载策略,实现按需加载,提高系统性能。 ```java @Entity public class User { @Id private Long id; private String name; @OneToMany(fetch = ...
1. **基本概念**:Hibernate的基础概念,如实体(Entity)、对象状态、持久化类、持久化标识(Primary Key)等。理解这些概念是掌握Hibernate的前提。 2. **配置**:如何设置Hibernate的配置文件(hibernate.cfg....
1. **对象关系映射(ORM)基础**: Hibernate是ORM框架的代表,它通过在Java对象和数据库表之间建立映射,消除了SQL语言与面向对象编程之间的隔阂。ORM允许开发者通过对象的方法来执行CRUD(创建、读取、更新和删除...
EAGER策略会立即加载关联数据,而LAZY策略则在需要时才加载,以提高性能。在联表查询时,选择合适的Fetch策略很重要。 9. **Criteria API中的Join操作** 使用Criteria API进行联表查询时,可以使用`createCriteria...
2. **配置文件**:`hibernate.cfg.xml`是Hibernate的核心配置文件,用于设置数据库连接、方言、缓存等信息,是启动 Hibernate 的基础。 3. **实体类(Entity)**:在Hibernate中,实体类代表数据库中的表,通过注解...
6. **查询优化**:Hibernate提供了延迟加载(Lazy Loading)、批处理(Batch Processing)等特性,优化了大数据量操作时的性能。延迟加载只在真正需要时才加载关联对象,而批处理则可以减少数据库交互次数。 7. **...
《深入理解Hibernate框架:基于4.2.4.Final版本》 Hibernate,作为一个强大的对象关系映射(ORM)框架,自推出以来就深受...实际项目中,开发者应根据需求选择合适的方法和策略,充分利用Hibernate提供的强大功能。
Hibernate ORM 是一个强大的Java对象关系映射(ORM)框架,它极大地简化了数据库与Java应用程序之间的数据交互...虽然现在Hibernate已经发展到了更高级的版本,但理解3.2的基础知识仍然有助于理解ORM的本质和工作原理。
4. @Basic(fetch = FetchType.LAZY):基础属性的懒加载。 总结,Hibernate 3.4.0.GA版本通过注解方式提供了强大的ORM功能,简化了数据库操作,提高了开发效率。理解和掌握这些注解的用法,能够帮助开发者更好地利用...
在使用Hibernate Annotations进行开发时,需要注意一些性能优化策略: 1. 合理选择查询方式:HQL(Hibernate Query Language)和Criteria API提供了灵活的查询手段,但应根据实际情况选择,避免N+1查询问题。 2. ...
5.1.2 Hibernate访问持久化类属性的策略 5.1.3 在持久化类的访问方法中加入程序逻辑 5.1.4 设置派生属性 5.1.5 控制insert和update语句 5.2 处理SQL引用标识符 5.3 创建命名策略 5.4 设置数据库Schema...
8. **懒加载(Lazy Loading)**:Hibernate支持延迟加载,即当需要时才加载关联的对象,有效防止内存溢出并提高性能。 9. **集合映射**:包括List、Set、Map等多种Java集合类型与数据库表的关联映射,支持一对一、...
以上是"美国硅谷SVSE软件工程教育Hibernate-Lesson2"课程中的主要内容,涵盖Hibernate的基础配置、对象映射、数据操作以及事务处理,为开发者提供了一套完整的Java对象到数据库记录的映射机制。学习这些知识将有助于...
1. **配置文件(hibernate.cfg.xml)**: 配置文件用于设置数据库连接信息、实体类位置、缓存策略等,是启动Hibernate的基础。 2. **映射文件(.hbm.xml或注解)**: 映射文件定义了实体类与数据库表之间的对应关系,...
然后,创建一个 `hibernate.cfg.xml` 配置文件,该文件用于定义数据库连接参数、方言、缓存策略等。 **实体类与映射文件** 在 Hibernate 中,每个 Java 类通常对应数据库中的一张表,而类的实例对应表中的记录。...
10. **懒加载(Lazy Loading)**:Hibernate 提供的一种优化策略,允许关联对象在首次访问时才加载,以避免不必要的数据冗余。 11. **集合映射**:支持多种类型的集合映射,如List、Set、Map等,以及一对多、多对一...