`
penghao122
  • 浏览: 362557 次
  • 性别: Icon_minigender_1
  • 来自: 广东珠海
社区版块
存档分类
最新评论

hibernate 全面学习【hibernate抓取策略 】

HibernateJavajunitXMLC 
阅读更多
Hibernate抓取策略

默认fetch的配置,也就fetch="select",参见Student.hbm.xml文件，如：
<many-to-one name="classes" column="classid" fetch="select" />

Hibernate抓取策略

设置fetch="join",参见Student.hbm.xml文件，如：
<many-to-one name="classes" column="classid" fetch="join" />

但是会导致lazy失效

Hibernate抓取策略

设置fetch＝“join”，参见：Classes.hbm.xml,如：
<set name="students" inverse="true" fetch="join">

但会导致lazy失效

Hibernate抓取策略

设置fetch＝“subselect”，参见：Classes.hbm.xml,如：
<set name="students" inverse="true" fetch="subselect">

Hibernate抓取策略

针对fetch="select"配置进行优化，加入batch，如：
<class name="com.bjsxt.hibernate.Classes" table="t_classes" batch-size="5">

Hibernate抓取策略

在集合上设置batch 


<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" inverse="true">
			<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"/>
		<many-to-one name="classes" column="classid" fetch="select" />
	</class>
</hibernate-mapping>

package com.bjsxt.hibernate;

import java.io.Serializable;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Student student = (Student)session.load(Student.class, 1);
			System.out.println("学生姓名：" + student.getName());
			System.out.println("所属班级:" + student.getClasses().getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}




<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" inverse="true">
			<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"/>
		<many-to-one name="classes" column="classid" fetch="join" />
	</class>
</hibernate-mapping>
package com.bjsxt.hibernate;

import java.io.Serializable;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Student student = (Student)session.load(Student.class, 1);
			System.out.println("学生姓名：" + student.getName());
			System.out.println("所属班级:" + student.getClasses().getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}





<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" inverse="true" fetch="select">
			<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"/>
		<many-to-one name="classes" column="classid"/>
	</class>
</hibernate-mapping>
package com.bjsxt.hibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Classes classes = (Classes)session.load(Classes.class, 1);
			System.out.println("班级:" + classes.getName());
			Set students = classes.getStudents();
			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);
		}
	}



<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" inverse="true" fetch="join">
			<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"/>
		<many-to-one name="classes" column="classid"/>
	</class>
</hibernate-mapping>

package com.bjsxt.hibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Classes classes = (Classes)session.load(Classes.class, 1);
			System.out.println("班级:" + classes.getName());
			Set students = classes.getStudents();
			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);
		}
	}
}




<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" inverse="true" fetch="subselect">
			<key column="classid"/>
			<one-to-many class="com.bjsxt.hibernate.Student"/>
		</set>
	</class>
</hibernate-mapping>

package com.bjsxt.hibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Classes classes = (Classes)session.load(Classes.class, 1);
			System.out.println("班级:" + classes.getName());
			Set students = classes.getStudents();
			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 testFetch2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			List Classes = session.createQuery("select c from Classes c where c.id in(1, 2, 3)").list();
			for (Iterator iter = Classes.iterator(); iter.hasNext();) {
				Classes cls = (Classes)iter.next();
				System.out.println("班级：" + cls.getName());
				for (Iterator iter1 = cls.getStudents().iterator(); iter1.hasNext();) {
					Student student = (Student)iter1.next();
					System.out.println(student.getName());
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
}




<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Classes" table="t_classes" batch-size="5">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!-- 
			<set name="students" cascade="all" order-by="id">
		 -->
		 <set name="students" inverse="true">
			<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"/>
		<many-to-one name="classes" column="classid"/>
	</class>
</hibernate-mapping>

package com.bjsxt.hibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			List students = session.createQuery("select s from Student s where s.id in(:ids)")
			                       .setParameterList("ids", new Object[]{1, 11, 21, 31, 41, 51, 61, 71, 81, 91})
			                       .list();
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println("学生：" + student.getName());
				System.out.println("班级：" + student.getClasses().getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}





<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" inverse="true" batch-size="5">
			<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"/>
		<many-to-one name="classes" column="classid"/>
	</class>
</hibernate-mapping>

package com.bjsxt.hibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

public class FetchTest extends TestCase {

	public void testFetch1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			List classes = session.createQuery("from Classes").list();
			for (Iterator iter = classes.iterator(); iter.hasNext();) {
				Classes cls = (Classes)iter.next();
				System.out.println("班级：" + cls.getName());
				for (Iterator iter1 = cls.getStudents().iterator(); iter1.hasNext();) {
					Student student = (Student)iter1.next();
					System.out.println(student.getName());
				}
			}	
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}
分享到：
| hibernate 全面学习【hibernate hsql语句学 ...
评论
2 楼 a114d 2012-01-11  
itling 写道
尚学堂的demo

楼上威武
1 楼 itling 2008-10-29  
尚学堂的demo
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    day36 08-Hibernate抓取策略：批量抓取

    本篇主要关注的是Hibernate的抓取策略，特别是批量抓取技术，这对于提高应用程序性能至关重要。批量抓取能够减少数据库交互次数，从而优化查询效率。 首先，我们要理解什么是抓取策略。在Hibernate中，抓取策略是指...

    hibernate3数据检索、抓取策略 、 注解的使用

    hibernate3数据检索、抓取策略 、 注解的使用

    day36 06-Hibernate抓取策略：set集合上的抓取策略

    在提供的压缩包文件"hibernate_day03"中，可能包含了相关的代码示例或教程，可以帮助你更直观地学习和体验Hibernate的抓取策略。通过深入学习和实践，你将能够更好地应对各种复杂的数据库操作场景。

    hibernate抓取策略和懒加载案例

    在Java的持久化框架Hibernate中，数据访问优化是至关重要的，而抓取策略（Fetch Strategy）和懒加载（Lazy Loading）则是实现这一目标的关键技术。本文将深入探讨这两个概念，并通过具体的案例进行分析。 首先，让...

    HIBERNATE检索策略

    描述：本文深入解析了HIBERNATE的检索策略，为读者提供了一条清晰的学习路径，重点分析了HIBERNATE中的抓取策略及其应用场景，帮助开发者更有效地管理和优化数据加载过程。 在HIBERNATE框架中，检索策略主要涉及...

    day36 07-Hibernate抓取策略：many-to-one上的抓取策略

    今天我们要讨论的是Hibernate框架中的一个关键概念——抓取策略，特别是针对"many-to-one"关系的抓取策略。这篇博客将深入剖析这个主题，帮助你更好地理解和应用Hibernate。 Hibernate是Java领域中最流行的对象关系...

    Hibernate框架 jar 架包 开发详解

    Hibernate 简介 Hibernate 开发流程 Hibernate 配置文件 Hibernate 核心接口和类 Hibernate ORM映射 HQL Hibernate 懒加载机制与抓取策略 Hibernate 缓存 Hibernate 锁机制

    Hibernate中文详细学习文档

    19.1.2. 调整抓取策略（Tuning fetch strategies） 19.1.3. 单端关联代理（Single-ended association proxies） 19.1.4. 实例化集合和代理（Initializing collections and proxies） 19.1.5. 使用批量抓取（Using...

    hibernate_reference

    Hibernate Reference官方文档是学习Hibernate的权威资料，提供了全面而深入的指南，适合希望深入了解Hibernate架构、配置和使用方法的开发者。文档覆盖了Hibernate的核心概念和高级特性，包括映射、配置、会话管理、...

    hibernate学习笔记

    综上所述，这份"hibernate学习笔记"全面覆盖了Hibernate的主要方面，包括对象生命周期管理、对象关系映射、查询方式以及性能优化。对于希望深入理解和掌握Hibernate的开发者来说，这是一个非常宝贵的资源。

    Hibernate学习笔记

    Hibernate还支持操作树形结构的数据，并提供了抓取策略来优化数据检索，比如Eager Fetching和Lazy Fetching。此外，Hibernate缓存机制（一级缓存和二级缓存）是性能优化的关键策略之一，它通过减少数据库的访问次数...

    Hibernate5.2.11高清版，最新版本

    抓取策略（Fetching）介绍了Hibernate如何抓取对象及其关联对象，包括延迟加载和立即加载的策略选择。 批量操作（Batching）涉及如何执行数据库批处理操作，这对于执行大量数据更新或插入非常有用。 缓存机制...

    HIBERNATE doc_document_官方文档_4.3.6_final_2014_8

    Hibernate文档旨在为开发者提供一个全面的学习和参考指南，从基础概念到高级特性，涵盖了使用Hibernate框架所需的各个方面。文档不仅解释了理论知识，还提供了实用的示例和最佳实践，帮助开发者在实际工作中更好地...

    Hibernate学习总结

    学习成长路，Hibernate总结： 1.Hibernate入门优缺点、 2.Hibernate的操作CRUD、 3.主键生成机制、 4.持久化对象的状态、 ...8.Hibernate检索策略(fetch抓取策略)、 9.二级缓存、 10.Hbernate的检索方式（HQL语句）

    Hibernate 参数配置详解

    - **描述**：为 Hibernate 关联的批量抓取设置默认的数量。 - **取值**：建议取值为 4、8、16。 - **示例**：`hibernate.default_batch_fetch_size=8` ##### 9. 默认实体模式 (Default Entity Mode) - **名称**：`...

    Hibernate中大量数据的更新

    在 Hibernate 配置文件中，可以设置 `hibernate.jdbc.batch_size` 参数来指定批量抓取的大小。 如何实现批量更新 在 Controller 层，需要将大量数据插入到数据库时，可以使用以下方法： ```java for (int i = 0; ...

    让hibernate输出sql语句参数配置.doc

    hibernate.default_batch_fetch_size 参数用于设置 Hibernate 关联的批量抓取默认数量。其取值建议为 4、8 或 16。 9. hibernate.default_entity_mode hibernate.default_entity_mode 参数用于指定由这个 ...

    hibernate 参考手册

    4. **可选配置属性**：列出了Hibernate中各种可选的配置属性，如SQL方言、外连接抓取策略等。 ### Hibernate的持久化类 1. **POJO例子**：通过一个简单的持久化类（POJO）的例子，介绍了Hibernate的实体映射细节。...

    Hibernate5中文用户使用手册

    包括基础抓取知识和应用抓取策略，例如通过查询和配置文件动态抓取数据。 批处理：Hibernate支持JDBC批处理，以提高批量数据操作的性能。 缓冲：讲解了如何配置二级缓冲以及管理缓冲数据。 拦截器和事件：这部分...

Magicbox
Global site tag (gtag.js) - Google Analytics