问题?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();
}
}