本章,采用Class和Student     ——  1 对 多的关系;

Student.java:

package com.cy.model;

public class Student {
private int id;
private String name;
private Class c; public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Class getC() {
return c;
}
public void setC(Class c) {
this.c = c;
} }

Class.java:

package com.cy.model;

import java.util.HashSet;
import java.util.Set; public class Class {
private int id;
private String name;
private Set<Student> students = new HashSet<Student>(); public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
} }

Student.hbm.xml:

<hibernate-mapping package="com.cy.model">

    <class name="Student" table="t_student">
<id name="id" column="stuId">
<generator class="native"></generator>
</id>
<property name="name" column="stuName"></property> <many-to-one name="c" column="classId" class="com.cy.model.Class" cascade="save-update" lazy="proxy"></many-to-one> </class> </hibernate-mapping>

Class.hbm.xml:

<hibernate-mapping package="com.cy.model">

    <class name="Class" table="t_class">
<id name="id" column="classId">
<generator class="native"></generator>
</id>
<property name="name" column="className"></property> <set name="students" cascade="save-update" inverse="true" lazy="false" batch-size="3" fetch="join">
<key column="classId"></key>
<one-to-many class="com.cy.model.Student" />
</set>
</class> </hibernate-mapping>

第一节:检索策略属性Lazy                                                  

Lazy:true:默认延迟检索:用到才加载

    @Test
public void testLazy1(){
//因为在class.hbm中set端,一对多,配置的是lazy=true,加载class的时候,默认是不加载学生的。
Class c = (Class) session.get(Class.class, 1); //等到什么时候会查询学生数据?——等到他用的时候
//等到用到的时候才去检索,这就是延迟检索
Set<Student> students = c.getStudents(); System.out.println(students.size()); // Iterator it = students.iterator(); }
 
lazy:false: 查询class,如果肯定会用到student信息的话,可以立即检索;设置lazy false也行的
 
lazy:extra:也是延迟的,但是增强的;
比如:配置lazy为true的话,想知道查询出来学生数量的话:
Class c = (Class) session.get(Class.class, 1);
Set<Student> students = c.getStudents();
System.out.println(students.size());
发出的sql为查询所有学生,然后知道3条记录;
但是其实只需要select count(*) from student就行了,这就是sql优化。配置lazy=extra就能实现;
但是实际开发用的也不多,因为很少只查询size的情况;
 
lazy:proxy:
取Student信息的时候,里面的班级Class是代理类,是不包含数据的;但是用到Class里面内容的时候,就通过代理类去数据库查询内容了。
    @Test
public void testLazy2(){
//many to one端,默认lazy - proxy。取出的student中的Class是一个代理类。没有实际数据
Student student = (Student) session.get(Student.class, 1); //等到用到class的名字的时候,代理类才去发出sql查询数据。
student.getC().getName();
}
 
lazy:no-proxy:
没有代理类,取student的时候,里面的class是个null值,等到用class内容了,再去查。很少用.......

第二节:检索策略属性batch-size                                          

1,批量延迟检索;

对应的class.hbm配置:lazy="true" batch-size="3"

/**
* 批量延迟检索,lazy=true
*/
@Test
public void testBatch1(){
List<Class> classList = session.createQuery("from Class").list();
Iterator<Class> it = classList.iterator();
Class c1 = it.next();
Class c2 = it.next();
Class c3 = it.next();
c1.getStudents().iterator();
c2.getStudents().iterator();
c3.getStudents().iterator(); //先取出所有class,因为set students端配置了lazy=false
//等到c1、c2、c3用到student的时候,才去查找。每个发出一条sql语句。
//假如classList很多很多的话,遍历每个class,然后取每个class下面的students,每个都发出一条sql,这样效率就很低了。
//所以,引入了batch-size,批量检索。batch-size的值为批量的值 //在class.hbm. set studens端,配置batch-size=3,发出的sql就是这样了:
/**
* SELECT
t_student.classId ,
t_student.stuId ,
t_student.stuName
FROM t_student
WHERE t_student.classId IN (1, 2, 3)
*/
}

而未设置批量检索batch-size,发出的sql是下面这样,一条一条的查:

设置了批量检索,batch-size=3后,查询student信息时,一次查3条;

2,批量立即检索;

@Test
public void testBatch2(){
List<Class> classList = session.createQuery("from Class").list();
//这里class.hbm.xml set students中配置lazy=false,batch-size=3,就是批量立即检索了.
//发出的批量sql和上面一样。 }

第三节:检索策略属性Fetch                                      

Fetch这里也是在class端配置的;
 
fetch:subselect,在数据量很大的时候,使用子查询,可以使性能得到优化点。
 
@Test
public void testFetch1(){
List<Class> classList = session.createQuery("from Class").list();
Iterator<Class> it = classList.iterator();
Class c1 = it.next();
Class c2 = it.next();
Class c3 = it.next();
c1.getStudents().iterator();
c2.getStudents().iterator();
c3.getStudents().iterator();
/**
* class.hbm set students 配置fetch="select",是默认的,发出的sql:
* SELECT
t_student.classId ,
t_student.stuId ,
t_student.stuName
FROM t_student
WHERE t_student.classId IN (1, 2, 3) 现在改为fetch=subselect:sql变成了:
SELECT
t_student.classId ,
t_student.stuId ,
t_student.stuName
FROM t_student
WHERE t_student.classId IN
(SELECT classId FROM t_class )
*
*/
}

fetch:join:

@Test
public void testFetch2(){
Class c = (Class) session.get(Class.class, 1);
/**
* 这里class.hbm配置:<set name="students" lazy="false" fetch="join">
* 查询班级的时候,把属于这个班级的学生也一起查出来,这里fetch=join,sql中left outer join:
* 发出的sql:
* SELECT
t_class.classId,
t_class.className,
t_student.stuId,
t_student.stuName,
t_student.classId
FROM t_class
LEFT OUTER JOIN t_student ON t_class.classId = t_student.classId
WHERE t_class.classId = 1 * 可以看到只发出一条sql语句了,t_class表和t_student表关联,将class信息和student信息一起取了出来;
*
* 而如果fetch为select,是先取班级信息;再取student信息
*/
}

Hibernate学习9—检索策略的更多相关文章

  1. Hibernate学习之检索策略

    一.类级别的检索策略 类级别可选的检索策略包括立即检索和延迟检索, 默认为延迟检索 –立即检索: 立即加载检索方法指定的对象 –延迟检索: 延迟加载检索方法指定的对象,在使用具体的属性时,再进行加载 ...

  2. Hibernate学习总汇

    Hibernate的基础知识 什么是框架? 什么是Hibernate框架? |--1.应用在javaee三层结构中的dao层 |--2.在dao层里面做对数据库进行crud操作,使用hibernate ...

  3. [原创]java WEB学习笔记88:Hibernate学习之路-- -Hibernate检索策略(立即检索,延迟检索,迫切左外连接检索)

    本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...

  4. [原创]java WEB学习笔记91:Hibernate学习之路-- -HQL 迫切左外连接,左外连接,迫切内连接,内连接,关联级别运行时的检索策略 比较。理论,在于理解

    本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...

  5. Hibernate学习(八)———— Hibernate检索策略(类级别,关联级别,批量检索)详解

    序言 很多看起来很难的东西其实并不难,关键是看自己是否花费了时间和精力去看,如果一个东西你能看得懂,同样的,别人也能看得懂,体现不出和别人的差距,所以当你觉得自己看了很多书或者学了很多东西的时候,你要 ...

  6. Hibernate —— 检索策略

    一.Hibernate 的检索策略本质上是为了优化 Hibernate 性能. 二.Hibernate 检索策略包括类级别的检索策略.和关联级别的检索策略(<set> 元素) 三.类级别的 ...

  7. hibernate学习(6)——加载策略(优化)

    1. 检索方式 1  立即检索:立即查询,在执行查询语句时,立即查询所有的数据. 2 延迟检索:延迟查询,在执行查询语句之后,在需要时在查询.(懒加载) 2.  检查策略 1  类级别检索:当前的类的 ...

  8. hibernate(八) Hibernate检索策略(类级别,关联级别,批量检索)详解

    序言 很多看起来很难的东西其实并不难,关键是看自己是否花费了时间和精力去看,如果一个东西你能看得懂,同样的,别人也能看得懂,体现不出和别人的差距,所以当你觉得自己看了很多书或者学了很多东西的时候,你要 ...

  9. 攻城狮在路上(壹) Hibernate(十二)--- Hibernate的检索策略

    本文依旧以Customer类和Order类进行说明.一.引言: Hibernate检索Customer对象时立即检索与之关联的Order对象,这种检索策略为立即检索策略.立即检索策略存在两大不足: A ...

随机推荐

  1. dell c6220II lsi阵列卡

    1.如果在lsi阵列卡上有多个raid,那么需要在第一个创建的raid上装系统,或者说先创建装系统的raid,否则可能报 hard disk error(centos 6.6) 2.热插拔的后果:如果 ...

  2. hdu 6097 Mindis(数学几何,圆心的反演点)

    Mindis Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Subm ...

  3. C++/C extern关键字详解 EntryPointNotFoundException处理

    最近在弄C#帮公司做一个图像识别的功能,用到了第三方的dll,在调用dll过程中就出现了一个问题.EntryPointNotFoundException异常.遇到这种异常,很大可能就是在生成dll时函 ...

  4. Linux:更改hostname主机名

    更改hostname主机名 查看主机名 hostname 临时更改主机名 hostname youname 更改永久生效主机名 1)更改配置文件 vi /etc/sysconfig/network 2 ...

  5. Selenium实现右键保存图片(Java)

    1.代码 public class SaveImage extends TestCase { private WebDriver driver; private Actions action; pri ...

  6. AOP代理模式

    AOP 在Spring框架中被作为核心组成部分之一,的确Spring将AOP发挥到很强大的功能.最常见的就是事务控制.工作之余,对于使用的工具,不免需要了解其所以然.学习了一下,写了些程序帮助理解. ...

  7. Android程序员学WEB前端(3)-HTML(3)-表单嵌套-Sublime

    转载请注明出处:http://blog.csdn.net/iwanghang/article/details/76522586觉得博文有用,请点赞,请评论,请关注,谢谢!~ 表单嵌套: <!DO ...

  8. softmax的多分类

    关于多分类 我们常见的逻辑回归.SVM等常用于解决二分类问题,对于多分类问题,比如识别手写数字,它就需要10个分类,同样也可以用逻辑回归或SVM,只是需要多个二分类来组成多分类,但这里讨论另外一种方式 ...

  9. swift 定义枚举和结构体 及使用

    //定义枚举 enum MapDirection { case North case South case East case West func simpleDescription() -> ...

  10. linux中使用yum进行软件的安装

    yum 仓库 配置信息/etc/yum.reposd/ [linuxcast]name="this is soft ware"baseurl="http://ww.bai ...