hibernate 全面学习【lazy策略 】

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量74 收藏
点赞数
文章标签： java 测试 python
原文链接：https://my.oschina.net/zlp5201/blog/404148
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

lazy策略可以用在： 
* <class>标签上：可以取值true/false 
* <property>标签上，可以取值true/false，这个特性需要类增强 
* <set>/<list>等集合上，可以取值为true/false/extra 
* <one-to-one>/<many-to-one>等标签上，可以取值false/proxy/no-proxy 

重要的概念： 
1、lazy的概念，指在需要的时候才发出sql 
2、lazy策略只是在session打开期间才是有效的 

注意： 
Hibernate类级别的lazy加载策略：可以控制什么时候加载这些普通对象属性 

测试单元的使用： 
请先运行初时化程序InitData,在执行每个单元测试 


Hibernate集合属性的懒加载策略： 

在集合属性上，可以配置懒加载策略，取值为：true/false/extra 

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其 
     集合元素的数据 
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据 
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据 


Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置 
懒加载策略。 

可以取值为：false/proxy/no-proxy 
false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象 
proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候 
      才真正发出查询语句查询其对象数据，其关联对象是代理类 
no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类 

注意：在class标签上配置的lazy属性不会影响到关联对象!!! 



Java代码 
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>	



Java代码 
package com.bjsxt.hibernate;
import org.hibernate.Session;

import com.bjsxt.hibernate.Group;
import com.bjsxt.hibernate.HibernateUtils;


public class InitData {

	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Group group = new Group();
			group.setName("java开发组");
			session.save(group);
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

}


Java代码 
  
package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 运行本单元测试的前提条件：
 * 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)
 * 
 * @author Administrator
 *
 */
public class ClassLazyTest extends TestCase {

	public void testLoadGroup1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Group group = (Group)session.load(Group.class, 1);
			
			//不会发出查询sql
			System.out.println("group id=" + group.getId());
			
			//发出查询sql，加载数据到Group
			System.out.println("group name=" + group.getName());
			
			//不会发出查询sql
			System.out.println("group name=" + group.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testLoadGroup2() {
		Session session = null;
		Group group = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			group = (Group)session.load(Group.class, 1);
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
		//不能正常输出，抛出了 LazyInitializationException，因为session已经关闭了
		//注意：Hibernate支持Lazy策略，只有session打开状态才有效		
		System.out.println("group name=" + group.getName());
		
	}
	
	
}





--------------------------------------------------------------------- 
集合类测试 

Java代码 
<hibernate-mapping>   
    <class name="com.bjsxt.hibernate.Classes" table="t_classes">   
        <id name="id">   
            <generator class="native"/>   
        </id>   
        <property name="name"/>   
        <!--    
            <set name="students" cascade="all" order-by="id">   
         -->   
         <set name="students" lazy="extra">   
            <key column="classid"/>   
            <one-to-many class="com.bjsxt.hibernate.Student"/>   
        </set>   
    </class>   
</hibernate-mapping>   
  
<hibernate-mapping>   
    <class name="com.bjsxt.hibernate.Student" table="t_student">   
        <id name="id">   
            <generator class="native"/>   
        </id>   
        <property name="name"/>   
    </class>   
</hibernate-mapping>  

Java代码 
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 保持lazy的默认值
 * @author Administrator
 *
 */
public class CollectionLazyTest1 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到Students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载全部的数据到Students
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}


Java代码 


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=false
 * @author Administrator
 *
 */
public class CollectionLazyTest2 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//不会发出查询sql
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//不会发出查询sql	
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

Java代码 
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=extra
 * @author Administrator
 *
 */
public class CollectionLazyTest3 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();

			//会发出一条较为智能的查询sql，如：
			//select count(id) from t_student where classid =?
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

---------------------------------------------------------------- 

单端关联加载 



Java代码 
  
<hibernate-mapping>   
    <class name="com.bjsxt.hibernate.Group" table="t_group">   
        <id name="id">   
            <generator class="native"/>   
        </id>   
        <property name="name"/>   
    </class>   
</hibernate-mapping>   
  
<hibernate-mapping>   
    <class name="com.bjsxt.hibernate.User" table="t_user" >   
        <id name="id">   
            <generator class="native"/>   
        </id>   
        <property name="name"/>   
        <!--   
        <many-to-one name="group" column="relatedGroup" />   
         -->   
           
        <many-to-one name="group" column="relatedGroup"/>    
    </class>   
</hibernate-mapping>        


<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.User" table="t_user" >
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!--
		<many-to-one name="group" column="relatedGroup" />
		 -->
		
		<many-to-one name="group" column="relatedGroup"/> 
	</class>
</hibernate-mapping>		



Java代码 
package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 所有lazy的属性默认
 * @author Administrator
 *
 */
public class SingleEndTest1 extends TestCase {

	public void testLoadUser() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			User user = (User)session.load(User.class, 2);
			
			//会发出一条查询sql，转载数据到User
			System.out.println("user name=" + user.getName());
			
			//不会发出查询sql
			Group group = user.getGroup();
			
			//会发出一条查询sql，转载数据到Group
			System.out.println("related group=" + group.getName());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			
		}
	}
}


Java代码 
package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 将<class>标签中的lazy设置为false
 * @author Administrator
 *
 */
public class SingleEndTest2 extends TestCase {

	public void testLoadUser() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//会发出一条查询sql，转载数据到User
			User user = (User)session.load(User.class, 2);
			
			//不会发出查询sql
			System.out.println("user name=" + user.getName());
			
			//不会发出查询sql
			Group group = user.getGroup();
			
			//会发出一条查询sql，转载数据到Group
			System.out.println("related group=" + group.getName());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			
		}
	}
}

Java代码 
package com.bjsxt.hibernate;   
  
import org.hibernate.Session;   
  
import junit.framework.TestCase;   
  
/**  
 * 保持<class>标签中的lazy默认设置  
 * 将<many-to-one>标签中加入lazy=false  
 * @author Administrator  
 *  
 */  
public class SingleEndTest3 extends TestCase {   
  
    public void testLoadUser() {   
        Session session = null;   
        try {   
            session = HibernateUtils.getSession();   
               
            //会发出一条查询sql，转载数据到User   
            User user = (User)session.load(User.class, 2);   
               
            //不会发出查询sql   
            System.out.println("user name=" + user.getName());   
               
            //不会发出查询sql   
            Group group = user.getGroup();   
               
            //会发出一条查询sql，转载数据到Group   
            System.out.println("related group=" + group.getName());   
               
        }catch(Exception e) {   
            e.printStackTrace();   
        }finally {   
               
        }   
    }   
}

 摘自：http://penghao122.javaeye.com/blog/211598

转载于:https://my.oschina.net/zlp5201/blog/404148

weixin_33901926
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入映射文件---hibernate学习笔记
如果一个人只能做好那么很少的几件事情 那么就做自己喜欢做的事
09-15 2355
先给出一份常见的持久化类配置文件大概熟悉一下
Hibernate之Lazy
最好的时光里
09-02 1839
前言   小编在敲一个SSH项目的时候碰到了“lazy”属性，但是又对这个东西不熟悉，因为从来没有用到过，所以就去网上搜了一些相关资料，下面是小编总结的搜到的东西，也当作笔记留在博客，以便以后用到的时候可以更方便的参考 一.延迟加载的概念   Hibernate 的延迟加载（lazy load）是一个被广泛使用的技术。这种延迟加载保证了应用只有在需要时才去数据库中抓取相应的记录。通过延迟...
hibernate 中lazy作用
zhoutao198712的专栏
11-17 4205
转载：  HIBERNATE的持久化对象加载策略。 延迟加载, 也就是用到的时候才去加载.这样可以提高一些性能. Hibernate的lazy loading 采用了一个HibernateSession来管理session，它的逻辑是每进行一次数据库操作，就开新的session，操作完成后立即关闭该session。这样做的好处是可以严格关闭session，避免菜鸟级的错误，但是hibern
Hibernate 级联操作，映射文件中的默认的Lazy属性导致的异常
loveblog1314的专栏
04-25 2805
hibernate中的延迟加载策略一定程度上降低了内存开销，但是有时候使用会出现不想要的异常。 首先，hibernate hbm 中lazy属性（true|false)，在hibernate中默认lazy是true。 Hibernate中允许使用延迟加载的地方主要有以下几个地方： ：设置全局的延迟加载策略。 ：DTD没设置默认值，推理默认值为true （在不同的hibernate中，l
jpa+hibernate5中lazy无效的解决办法(JpaRepository的save方法源码解析）
山间明月江上清风的专栏
01-03 2110
今天发现fetch = FetchType.LAZY这个设置无效，在查询和新增都会查一遍。 @ManyToOne(optional = false, fetch = FetchType.LAZY) @JoinColumn(name = "loan_req_no", referencedColumnName = "loanReqNo", insertable = false, updatab...
Hibernate最全面试题
3y
03-09 569
Hibernate常见面试题 Hibernate工作原理及为什么要用？ Hibernate工作原理及为什么要用？ 读取并解析配置文件 读取并解析映射信息，创建SessionFactory 打开Sesssion 创建事务Transation 持久化操作 提交事务 关闭Session 关闭SesstionFactory 使用Hibernate框架就不用我们写...
Hibernate注解详解(超全面)
2401_85111824的博客
05-29 677
通过****@JoinColumn****注解定义一对一的关联关系。通过****@SequenceGenerator****一般通过连接表来实现这种关联，可以通过****@JoinColumn****注解来描述这种单向关联关系。@Table 注解包含一个schema和一个catelog 属性，使用****@UniqueConstraints**** 可以定义表的唯一约束。Plane 是父类****。********@DiscriminatorColumn**** 注解定义了辨别符列。
hibernate 全面学习【hibernate抓取策略 】
penghao122
07-04 88
Hibernate抓取策略 默认fetch的配置,也就fetch="select",参见Student.hbm.xml文件，如： Hibernate抓取策略 设置fetch="join",参见Student.hbm.xml文件，如： 但是会导致lazy失效 Hibernate抓取策略 设置fetch＝“join”，参见：Classes.hbm.xml,如...
Hibernate3.3_学习笔记.doc.zip
06-02
总之，《Hibernate3.3_学习笔记》这份文档全面覆盖了Hibernate3.3的核心知识点，从基础概念到高级用法，为开发者提供了详实的学习资料。通过深入学习，开发者不仅能熟练使用Hibernate，还能更好地理解和应对各种...
Hibernate学习资料
06-11
2. lazy loading：延迟加载策略，只在需要时加载关联对象，减少数据库交互。 3. batch-size：批量操作，如批处理插入，提高效率。 九、 Hibenate与Spring整合 1. Spring的HibernateTemplate和HibernateDaoSupport...
hibernate学习资料大全
12-22
以上只是压缩包中部分可能包含的知识点，实际学习资料可能包括教程文档、示例代码、实战项目等，通过深入学习和实践，开发者可以全面掌握Hibernate的精髓，并将其应用到实际开发中，提高开发效率，降低维护成本。...
jpa 全面学习资料
11-13
以下是对JPA的全面学习资料的详细概述： **1. JPA简介** JPA是Java EE 5引入的一种规范，目的是为了统一ORM框架，如Hibernate、TopLink等。它定义了如何在Java应用中表示和操作持久化对象，通过接口和注解实现...
golang 接口
m0_70982551的博客
07-24 878
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 465
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 572
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 553
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 348
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 400
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Hibernate框架深度学习：从入门到精通
"这篇《Hibernate学习笔记》涵盖了Hibernate的基础到高级特性的讲解，包括了O/R...这篇笔记是学习和理解Hibernate的全面指南，无论你是初学者还是有经验的开发者，都能从中受益，提升你的ORM技能和Java Web开发能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值