hibernate的懒加载和抓取策略解析
问题？hibernate的懒加载解析
什么是懒加载？
答：在Hibernate框架中，当我们要访问的数据量过大时，明显用缓存不太合适， 因为内存容量有限 ，为了减少并发量，减少系统资源的消耗，这时Hibernate用懒加载机制来弥补这种缺陷，但是这只是弥补而不是用了懒加载总体性能就提高了。
我们所说的懒加载也被称为延迟加载，它在查询的时候不会立刻访问数据库，而是返回代理对象，当真正去使用对象的时候才会访问数据库。
懒加载的作用：性能优化：
分类：
1、类得懒加载
2、集合的懒加载
3、单端关联的懒加载(多对一)
懒加载
1、类的懒加载
1、利用session.load方法可以产生代理对象
2、在session.load方法执行的时候并不发出sql语句
3、在得到其一般属性的时候发出sql语句
4、只针对一般属性有效，针对标示符属性是无效的
5、默认情况就是懒加载
2、集合的懒加载
false 当session.get时，集合就被加载出来了
true 在遍历集合的时候才加载
extra
针对集合做count,min,max,sum等操作
3、单端关联的懒加载(多对一)
<many-to-onelazy="false/no-proxy/proxy"> no-porxy默认值 true
根据多的一端加载一的一端，就一个数据，所以无所谓
总结：懒加载主要解决了一个问题：类、集合、many-to-one在时候发出SQL语句，加载数据
1、 通过Session.load()实现懒加载
load(Object, Serializable)：根据id查询 。查询返回的是代理对象，不会立刻访问数据库，是懒加载的。当真正去使用对象的时候才会访问数据库。
用load()的时候会发现不会打印出查询语句，而使用get()的时候会打印出查询语句。
使用load()时如果在session关闭之后再查询此对象，会报异常：could not initialize proxy - no Session。处理办法：在session关闭之前初始化一下查询出来的对象：Hibernate.initialize(user);使用load()可以提高效率，因为刚开始的时候并没有查询数据库。但很少使用。
代理错误：
2、 one-to-one(元素)实现了懒加载。
在一对一的时候，查询主对象时默认不是懒加载。即：查询主对象的时候也会把从对象查询出来。
需要把主对象配制成lazy="true" constrained="true" fetch="select"。此时查询主对象的时候就不会查询从对象，从而实现了懒加载。
一对一的时候，查询从对象的是默认是懒加载。即：查询从对象的时候不会把主对象查询出来。而是查询出来的是主对象的代理对象。
3、 many-to-one（元素）实现了懒加载。
多对一的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。
多对一的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。
hibernate3.0中lazy有三个值，true，false，proxy,默认的是lazy="proxy".具体设置成什么要看你的需求，并不是说哪个设置就是最好的。在<many-to-one>与<one-to-one>标签上:当为true时,会有懒加载特性,当为false时会产生N+1问题,比如一个学生对应一个班级,用一条SQL查出10个学生,当访问学生的班级属性时Hibernate会再产生10条SQL分别查出每个学生对应的班级.
lazy= 什么时候捉取
fetch= 捉取方式:select=关联查询;join=连接表的方式查询(效率高)
fetch=join时,lazy的设置将没有意义.
4、 one-to-many(元素)懒加载：默认会懒加载，这是必须的，是重常用的。
一对多的时候，查询主对象时默认是懒加载。即：查询主对象的时候不会把从对象查询出来。
一对多的时候，查询从对象时默认是懒加载。即：查询从对象的时候不会把主对象查询出来。
需要配置主对象中的set集合lazy="false" 这样就配置成是不懒加载了。或者配置抓取方式fetch="join"也可以变成不懒加载。
案例：
用一对多的案例来解析：
首先是搭建hibernate的环境。这个在我的文章中有详解
一的哪一方：Classes.java
package cn.itcast.hibernate.domain;
import java.io.Serializable;
import java.util.Set;
public class Classes implements Serializable {
private Long cid;
private String cname;
private String description;
private Set<Student> student;
public Long getCid() {
return cid;
}
public void setCid(Long cid) {
this.cid = cid;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Set<Student> getStudent() {
return student;
}
public void setStudent(Set<Student> student) {
this.student = student;
}
}
该持久类的映射文件：
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="cn.itcast.hibernate.domain.Classes">
<id name="cid" length="5" type="java.lang.Long">
<generator class="increment"></generator>
</id>
<property name="cname" length="20" type="java.lang.String"></property>
<property name="description" length="100" type="java.lang.String"></property>
<!--
set元素对应类中的set集合
通过set元素使classes表与student表建立关联
key是通过外键的形式让两张表建立关联
one-to-many是通过类的形式让两个类建立关联
cascade 进行级联操作
save-update
1、当 保存班级的时候，对学生进行怎么样的操作
如果学生对象在数据库中没有对应的值，这个时候会执行save操作
如果学生对象在数据库中有对应的值，这个时候会执行update操作
delete 在删除一这个对象时，随便删掉多里面的外键
all 在删除一时删除多中的外键，再进行更新一的时候更新多中的外键
inverse 维护关系(classes是否维护student之间的关系，
inverse在哪个映射文件，就是誰维护。如果为true，进行级联操作的时候就不会同时更新外键了)
true 不维护关系
false 维护关系
default false(默认维护，一般情况下我们采用级联操作的时候
，就出现外键也添加了，就是因为这个原因。
不过既然进行级联操作，也就意味着我们是需要两个有关系的。所以，我们选择默认值)
-->
<set name="student" cascade="save-update" inverse="true" lazy="true" fetch="join">
<!--
lazy="true"或者"extra"或者"false"
默认为true：这个只有在遍历的时候才进行加载，叫集合延迟加载
extra:这个更牛，如果是在只需要表中数据条目或者大小，统计的情况下加载的话，我就用这个，加载更快，不需要其他内容。
false:表示什么，在发出session.get时就进行加载，想对true时速度快点儿。
-->
<!-- join 左外连接
：如果把需求分析翻译sql语句，存在子查询，这个时候用该策略不起作用
select 默认
：先查询一的一端，再查询多的一端
subselect 子查询
：如果需要分析翻译成sql语句存在子查询，这个时候用该策略效率最高 -->
<!-- key是用来描述外键 -->
<key column="cid"></key>
<one-to-many class="cn.itcast.hibernate.domain.Student"/>
</set>
</class>
</hibernate-mapping>
多的哪一方:Student.java
package cn.itcast.hibernate.domain;
import java.io.Serializable;
public class Student implements Serializable {
private Long sid;
private String sname;
private String description;
private Classes classes;//多了一个类对象
public Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
public Long getSid() {
return sid;
}
public void setSid(Long sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
该映射文件为：
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="cn.itcast.hibernate.domain.Student">
<id name="sid">
<generator class="increment"></generator>
</id>
<property name="sname" length="20"></property>
<property name="description" length="100"></property>
<!--
多对一
column 外键
-->
<!--加的这个外键只是相对以前的一对多单项操作上，能够从多的放心来操作一，从而实现了双向操作。 通过外键来访问一 -->
<many-to-one name="classes" class="cn.itcast.hibernate.domain.Classes" column="cid" cascade="save-update"></many-to-one>
<!-- unique="true"外键相同的只能出现一次 -->
</class>
</hibernate-mapping>
hibernate.cfg.xml配置文件：
<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <!-- 一个session-factory只能连接一个数据库，一般我们也只写一个。 --> <session-factory> <!-- 数据库的用户名 --> <property name="connection.username">root</property> <!-- 数据库的密码 --> <property name="connection.password">root</property> <!-- 数据库的url:itcast_sh_hibernate是你用的数据库 --> <property name="connection.url"> jdbc:mysql://localhost:3306/itcast_sh_hibernate </property> <!-- @hbm2ddl.auto 作用：根据持久化类和映射文件生成表 validate:验证持久化类在映射文件中描述正不正确，只验证 create-drop：hibernate容器开启的时候生成表，关闭的时候删除表(不用) create:hibernate容器开启的时候生成表(不用) update:表示hibernate开启的时候，先检查持久化类和映射问件和表到底对应不对应， 不对应的话，我新建一个表。对应的话，验证描述正不正确(validate) --> <property name="hbm2ddl.auto">update</property> <!-- 显示hibernate内部生成的sql语句 --> <property name="show_sql">true</property> <!--@mapping resource 表示和映射文件相对应 --> <mapping resource="cn/itcast/hibernate/domain/Classes.hbm.xml" /> <mapping resource="cn/itcast/hibernate/domain/Student.hbm.xml" /> </session-factory> </hibernate-configuration>
工具类：
package cn.itcast.hibernate.util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Before;
public class HibernateUtil {
public static SessionFactory sessionfactory;
public static String url;
@Before
public void init(){
Configuration configuration=new Configuration();
configuration.configure(url);
sessionfactory=configuration.buildSessionFactory();
}
}
测试类：
package cn.itcast.hibernate.test;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import cn.itcast.hibernate.domain.Classes;
import cn.itcast.hibernate.domain.Student;
import cn.itcast.hibernate.util.HibernateUtil;
public class CreateTest extends HibernateUtil {
static{
url="/hibernate.cfg.xml";
}
/**
* 类得懒加载:该代理只对一般属性有效，对标识符属性是无效的。
*/
@Test
public void LoadTest(){
Session session=sessionfactory.openSession();
// Transaction transaction=session.beginTransaction();
// transaction.commit();
Classes classes=(Classes)session.load(Classes.class, 1L);
System.out.println(classes);
classes.getCname();
session.close();
}
/**
* 集合的延迟加载:只有在遍历的时候才发出sql语句的，叫集合的延迟加载
*/
@Test
public void ListTest(){
Session session=sessionfactory.openSession();
Classes classes=(Classes)session.load(Classes.class, 5L);
Set<Student> students=classes.getStudent();
for(Student s:students){
System.out.println(s.getSname());
}
session.close();
}
}
类得懒加载:这个是在得到属性的时候发出sql语句
集合延迟加载：
二、抓取策略(这只是hibernate的一种优化手段，并不是必须的。hql语句还有更好的优化手段)
抓取策略：
1、研究的主要是set集合如何提取数据，也就是如何发出sql语句。(注：而懒加载则是研究什么时候发出sql语句)
2、在Classes.hbm.xml文件中
<set fetch="join/select/subselect">
join 左外连接
如果把需求分析翻译sql语句，存在子查询，这个时候用该策略不起作用
select 默认
先查询一的一端，再查询多的一端
subselect 子查询
如果需要分析翻译成sql语句存在子查询，这个时候用该策略效率最高
sql语句说明什么是左外连接：
注意;下面这个表非常重要。
所以我们一般采用的是将抓取策略和懒加载相结合使用(一个是如何发出sql语句，一个是什么时候发出sql语句，从而优化性能)。
案例：下载：抓取策略和懒加载案例下载。
package cn.itcast.hibernate.test;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.junit.Test;
import cn.itcast.hibernate.domain.Classes;
import cn.itcast.hibernate.domain.Student;
import cn.itcast.hibernate.util.HibernateUtil;
public class FetchTest extends HibernateUtil {
static{
url="/hibernate.cfg.xml";
}
/**
* 查询所有班级和所有班级关联的学生
* n+1的问题:这样的话，效率极低：如下例子
* 解决问题的方案：子查询 fetch="subselect"
*/
@Test
public void testAll_Classes(){
Session session = sessionfactory.openSession();
List<Classes> cList = session.createQuery("from Classes").list();
for(Classes classes:cList){
Set<Student> students = classes.getStudent();
for(Student student:students){
System.out.println(student.getSname());
}
}
session.close();
}
//子查询的形式来找学生。不过首先是，在一的那方set中设置为fetch="subselect"
@Test
public void testClasses_Some(){
Session session = sessionfactory.openSession();
List<Classes> cList = session.createQuery("from Classes where cid in(1,2,3)").list();
for(Classes classes:cList){
Set<Student> students = classes.getStudent();
for(Student student:students){
System.out.println(student.getSname());
}
}
session.close();
}
@Test
public void testQueryClasses_Id(){
Session session = sessionfactory.openSession();
Classes classes = (Classes)session.get(Classes.class, 1L);
Set<Student> students = classes.getStudent();
for(Student student:students){
System.out.println(student.getSname());
}
session.close();
}
}