你的位置:首页 > Java教程

[Java教程]Hibernnate延迟加载策略(这么详细你还看不懂)


好久没有认真写过博客了,今天就好好的写一篇吧!!!!!!!!!

当Hibernate 从数据库中加载某个对象(例如:Dept对象)时,如果同时自动加载所有的关联的某个对象(例如:Emp对象),而程序实际上仅仅需要访问Dept对象,那么这些关联的Emp对象就白白浪费了许多内存空间。发生这种情况的原因是:就是立即加载的问题。

1.什么是立即加载呢?

Hibernate 查询 Dept 对象时,立即加载并加载与之关联的Emp对象,这种查询策略称为 立即加载

立即加载存在两大不足:

1.select 语句的数目太多,需要频繁地访问数据库,会影响查询性能。

2.在应用程序只需要访问Dept对象时,而不需要访问Emp对象的场合,加载Emp对象完全是多余的操作,这些多余的Emp对象就白白的浪费了许多内存空间。

 

那么我们必须要解决这个问题,所以就要谈到了“延迟加载”的知识了,延迟加载策略能避免加载应用程序不需要访问的关联对象,以优化查询性能。

不过我们要知道有多种查询策略,接下来我们就一起来分析每一种查询策略的加载问题。

第一种:类级别的查询策略

类级别可选的加载策略包括立即加载和延迟加载,默认是延迟加载,如果,<class>元素的lazy的属性为true,表示采用延迟加载;如果lazy 属性 为 false,表示采用立即加载。

我们现在以代码来解释是最好的办法。

1.立即加载策略

我们在Dept.hbm.文件中 加 lazy=“false”  属性,即可。

表结构:

 

测试代码:

  Session session = HibernateUtil.currentSession();    session.beginTransaction();    Dept dept = (Dept)session.load(Dept.class, 1);    System.out.println("部门名称"+dept.getdName());    System.out.println("===================");    Dept dept2 = (Dept)session.load(Dept.class, 1);    System.out.println("部门名称"+dept2.getdName());    session.getTransaction().commit();    HibernateUtil.closeSessio();

测试结果:

 

我们知道使用Load方法加载的是代理对象,只会在属性里保存一个OID,但是如果在Dept映射文件中配置了类级别的lazy为false就代表加载该对象时立即加载,也就是立即检索一次数据库,发出了一条sql语句。

2.延迟加载

类级别的默认加载策略就是延迟加载。在在Dept.hbm.文件中 ,以下两种方式都表示延迟加载策略。

 

或是

 

如果程序加载一个持久化对象的目的是为了访问它的属性,这是我们可以采用立即加载,但是如果程序加载一个持久化对象的目的是为了获得它的引用,这是我们可以采用延迟加载,无须访问Dept对象的属性。

看例子:

   

  Dept dept = (Dept)session.load(Dept.class, 1);    System.out.println("部门名称"+dept.getdName());    Employee emp=new Employee();    emp.setEname("李四");    emp.setDept(dept);    session.save(emp);

 

这段代码向数据库保存了 一个Employee 对象,它与已经存在的一个Dept持久化对象关联。如果在Dept 类级别 采用延迟加载,则 session.load()方法不会执行访问DEPT 表的select 语句,只返回一个Dept的代理对象,它的deptNo的属性值为1,其余属性都为NULL。session.save()方法执行的sql语句:

 

所以当,<class>元素的lazy属性为true时,会影响session.load()方法的各种运行时行为。举例说明:

1.如果加载的Dept对象在数据库中不存在时,不会抛出异常,只有运行dept.getxxx()时,才会抛出异常。

测试代码:

  Session session = HibernateUtil.currentSession();    session.beginTransaction();    Dept dept = (Dept)session.load(Dept.class, 3);    System.out.println("部门名称"+dept.getdName());    Employee emp=new Employee();    emp.setEname("李四");    emp.setDept(dept);    session.save(emp);

 

当 deptNo为3不存在时,会抛出以下异常:

 

2.如果在在整个Session范围内,应用程序没有访问过的Dept对象,那么Dept代理类的实例一直不会被初始化,Hibernater 不会执行任何的select语句。以下代码试图在关闭Session后访问的Dept游离对象:

测试代码:

Session session = HibernateUtil.currentSession();    session.beginTransaction();    Dept dept = (Dept)session.load(Dept.class, 3);    HibernateUtil.closeSessio();    System.out.println("部门名称"+dept.getdName());    session.getTransaction().commit();    HibernateUtil.closeSessio();

 

从代码中我们可以看出,session被提前关闭,所以dept引用的Dept代理类的实例在Session范围内始终没有被初始化,所以当执行到  System.out.println("部门名称"+dept.getdName())时,会抛出以下异常:

 

 

由此可见,Dept代理类的实例只有在当前的Session范围内才能被初始化。

3.import org.hibernate.Initialized()静态方法,用于在Session范围内显式初始化代理类实例,isInitialized()方法用于判断代理类实例是否已经被初始化。

代码:

Dept dept = (Dept)session.load(Dept.class, 1);if(!Hibernate.isInitialized(dept)){Hibernate.initialize(dept);HibernateUtil.closeSessio();System.out.println("部门名称"+dept.getdName());}

 

以上代码在Session范围内通过Hibernate 类的Initialized()方法显式初始化了Dept代理类实例,因此关闭Session关闭后,可以正常访问Dept的游离对象。

4.当程序访问代理类实例的getDeptNo()方法时,不会触发Hibernate 初始化 代理类实例的行为。例如:

代码:

Dept dept = (Dept)session.load(Dept.class, 1);   System.out.println("编号:"+ dept.getDeptNo());HibernateUtil.closeSessio();System.out.println("部门名称"+dept.getdName());

 

当程序访问dept.getDeptNo()方法时,该方法直接返回Dept代理类的实例OID值,无须查询数据库。由于变量dept始终引用的是没有初始化的Dept代理类的实例,因此当Session关闭后再执行dept.getdName()方法,会抛出以下异常。

 

但是值得我们注意的是:不管Dept.hbm.文件的<class>元素的属性是true还是false,Session 的get方法及Query对象的list方法在Dept类级别总是使用立即加载策略。举例说明:

1.Session的get方法总是立即到数据库中查询Dept查询对象,如果在数据库中不存在相应的数据,就会返回NULL,例如:

代码:

 

Session session = HibernateUtil.currentSession();    session.beginTransaction();    Dept dept = (Dept)session.get(Dept.class, 3);    System.out.println(dept);

 

结果:

 

由此可知,get方法永远不会执行Dept的代理类实例。

2.Query的list方法总是立即到数据库中查询Dept对象

 

代码:

List<Dept> query = session.createQuery("from Dept").list();    for (Dept dept : query) {      System.out.println(dept.getdName());    }

结果:

 

到了这里,算是把第一种类级别的查询策略写的差不多了。

第二种:一对多和多对一关联的查询策略

添加一个小知识点:

01.一对多或者多对多检索策略由lazy和fetch共同确定

 

02.fetch取值

    Join:迫切    Lazy:决定关联对象初始化时机

左外连接

    Select:多条简单SQL(默认值)

    Subselect:子查询

03.fetch和lazy组合

  解析:fetch=”join” lazy会被忽略,迫切左外连接的立即检索

        Fetch=”s    Fetch:决定SQL语句构建形式

elect” lazy=”false”  多条简单SQL立即检索

        Fetch=”select” lazy=”true”  多条语句延迟检索

        Fetch=”select” lazy=”extra”  多条语句及其懒惰检索

        Fetch=”subselect” lazy=”false”  子查询立即检索

        Fetch=”subselect” lazy=”true”  子查询延迟检索

        Fetch=”subselect” lazy=”extra”  子查询及其懒惰检索

Extra:及其懒惰,只有访问集合对象的属性时才会加载,访问集合本身的属性时(例如,集合大小,生成count),不会立即加载。

注意:query的list()会忽略映射文件配置的左外连接查询,fetch,此时lazy属性重新生效。

 

 

在映射文件中,用<SET>元素来配置一对多关联及多对一关联关系的加载策略。Dept.hbm.

 <!-- 双向   cascade:级联   inverse:反转 -->      <!--set表明Dept类的emps属性为set集合类型 -->      <!--order-by 对集合排序 order-by="dName asc  order-by="dName desc-->      <set name="emps" inverse="true" lazy="true">      <!--employee表的外键 deptNo -->      <key column="deptNo"></key>      <!--一对多  class 属性设定与所关联的持久化类 为employee -->      <one-to-many class="Employee"/>      </set>

 

这里的<set>元素有lazy属性,主要取决于emps集合被初始化的时机,到底是在加载Dept对象时就被初始化,还是在程序访问emps集合时被初始化。

1.立即加载

Dept.hbm.

测试代码:

      Dept dept = (Dept)session.get(Dept.class, 1);    System.out.println(dept.getdName());    

结果:执行Session的get方法时,对于Dept对象采用类级别的立即加载策略,对于Dept对象的emps集合(Dept关联所有的employee对象),采用一对多关联的立即加载策略。

 

 从这个结果我们可以看到,Hibernate加载了一个Dept对象和Employee对象,但是我们知道很多情况下,不需要访问Employee对象,所以我们就得用了 延迟加载策略。

2.延迟加载

对于<set>元素,应该优先考虑使用的默认延迟加载策略。

 

测试代码:

  Dept dept = (Dept)session.get(Dept.class, 1);    System.out.println(dept.getdName());    

结果:

很明显,只执行了一条sql语句,即仅仅加载了Dept对象。

Session的get方法,返回的是Dept对象的emps属性引用一个没有被初始化的集合代理类实例。换句话说,此时的emps集合中没有存放任何Emp对象,只有emps集合代理类实例被初始化时,才回到数据库查询所有与Dept关联的Emp对象。

测试代码:

  Dept dept = (Dept)session.get(Dept.class, 1);    System.out.println(dept.getdName());        for (Employee emp : dept.getEmps()) {      System.out.println(emp.getEname());    }

结果:

 

那么,Dept对象的emps属性引用的集合代理类实例何时被初始化呢?主要包括以下两种情况:

01.当应用程序第一次访问它时,如调用 iterator(),size(),isEmpty(),或是 contains()方法时:

代码:

  Dept dept = (Dept)session.get(Dept.class, 1);    Set<Employee> emp=dept.getEmps();    System.out.println(dept.getdName());        Iterator<Employee> itee=emp.iterator();//emps被初始化

02.通过hibernate的静态方法initialize()来初始化它。

  Dept dept = (Dept)session.get(Dept.class, 1);    Set<Employee> emp=dept.getEmps();    System.out.println(dept.getdName());    Hibernate.initialize(emp);//emps被初始化

3.增强延迟加载

lazy="extra"

配置如下:

 

增强延迟加载策略能进一步延迟Dept对象的emps集合代理类实例初始化时机。当应用程序第一次访问emps属性的iterator()时,会导致emps集合代理类的实例初始化。但是当当应用程序第一次size(),isEmpty(),或是 contains()方法时,emps不会初始化emps集合代理实例。仅仅通过查询select语句必要信息。

测试代码:

Dept dept = (Dept)session.get(Dept.class, 1);
//不会初始化emps集合代理类实例
int size = dept.getEmps().size();
System.out.println(size);

//会初始化emps集合代理类实例
Iterator<Employee> iterator = dept.getEmps().iterator();
System.out.println(iterator);


结果:

现在是第三种:多对一关联的查询策略

lazy=proxy

 Employee.hbm.

1.延迟加载策略。

测试代码:

Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句    Dept dept = em.getDept();    System.out.println(dept.getdName());//执行Dept对象

当Sesson执行get()方法时,仅仅立即执行查询Employee对象的select语句。当Employee 对象引用Dept代理类实例,这个代理类实例的IOD由Employee 表的DeptNo外键值决定。 当执行dept.getdName()时,hibernate 初始化Dept代理类实例,执行以下select语句到数据库中加载Dept对象。

结果:

 

无代理延迟加载:

lazy="no-proxy" 

测试代码:

    Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句    Dept dept = em.getDept();    System.out.println(dept.getdName());//执行Dept对象

如果Employee对象的dept属性使用无代理延迟加载,即<many-to-many>元素的lazy属性为no-proxy,当执行 get方法时,加载的Employee的dept属性为NULL,当执行到  em.getDept()时,将触发hibernate执行查询Dept 表的select 语句,从而加载Dept对象。

结果:

由此可见,当lazy为proxy 时,可以延长延迟加载 Dept对象的时间,而当lazy属性为no-proxy时,则可以避免使用由hibernate 提供的Dept代理类实例,使用hibernate 对程序 提供更加透明的持久化服务。

立即加载:

lazy=“false”

测试:

  Employee em=(Employee) session.get(Employee.class, 21);

结果:

可以看到,执行了两条sql语句。 

Open Session In View 模式9

Open Session In View 模式的作用:

 Hibernate 允许对关联对象、属性进行延迟加载,但是必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。如果 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层,当 Web 层访问到那些需要延迟加载的数据时,由于加载领域对象的 Hibernate Session 已经关闭,这些导致延迟加载数据的访问异常。

在Java Web 应用中,通常需要调用ibernate API 获取到显示的某个要显示的某个对象并传给相应但的视图JSP, 并在JSP中从这个对象导航到与之关联的对象或集合数据。这些关联对象或集合数据如果是被延迟加载的,hibernate 就会抛出以下异常:

这是因为在调用完hibernate完之后,Session 对象已经关闭了。针对这个问题,hibernate 社区提供了Open Session In View 模式 的解决方案!!

代码示例:

HibernateUtil代码

 private static final ThreadLocal<Session> sessionTL=new ThreadLocal<Session>();//私有的静态的配置对象 private static Configuration configuration;//私有的静态的工厂对象 private final static SessionFactory sessionFactory; //静态代码块,负责给成员变量赋值 static{   configuration=new Configuration().configure();   sessionFactory=configuration.buildSessionFactory(); } //从SessionFactory 连接池      获取一个和当前thread bind session public static Session currentSession(){  //2.返回当前的线程其对应的线程内部变量

      //sessionTL的get()方法根据当前线程返回其对应的线程内部变量,

     //也就是我们需要的Session,多线程情况下共享数据库连接是不安全的。

       //ThreadLocal保证了每个线程都有自己的Session.

   Session session=sessionTL.get();   //如果当前线程是session 为空=null ,则打开一个新的Session   if(session==null){     //创建一个session对象     session=sessionFactory.openSession();     //保存该Sessioon对象到ThreadLocal中     sessionTL.set(session);     }   return session; } //关闭Session public static void closeSessio(){   Session session=sessionTL.get();   sessionTL.set(null);   session.close();   }

biz层代码:

HibernateDao dao=new HibernateDao();  public Object get(Class clazz,Serializable id){      Object obj= dao.get(clazz, id);return obj;  }

dao层代码:

public Object get(Class clazz,Serializable id){      Object result= HibernateUtils.currentSession().load(clazz, id);      return result;  }

filter层代码:

public void doFilter(ServletRequest request, ServletResponse response,      FilterChain chain) throws IOException, ServletException {          Session session = null;    Transaction tx = null;    try {            session = HibernateUtils.currentSession();      System.out.println("filter\t"+session.hashCode());          tx = session.beginTransaction();                  // 执行请求处理链  双向过滤      chain.doFilter(request, response);      // 返回响应时,提交事务      tx.commit();    } catch (HibernateException e) {      e.printStackTrace();      tx.rollback();    } finally {      // 关闭session      HibernateUtils.closeSession();    }  }

过滤器在网站

<?"1.0" encoding="UTF-8"?><web-app version="2.5"   ="http://java.sun.com/"   ="http://www.w3.org/2001/"   xsi:schemaLocation="http://java.sun.com/  http://java.sun.com/ <display-name></display-name>   <!-- 过滤器 --> <filter>  <filter-name>openSessionInView</filter-name>  <filter-class>cn.happy.filter.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping>  <filter-name>openSessionInView</filter-name>  <url-pattern>/*</url-pattern> </filter-mapping> <welcome-file-list>  <welcome-file>index.jsp</welcome-file> </welcome-file-list></web-app>

index.jsp页面的代码:

<body>  <%     HibernateBiz biz=new HibernateBiz();    Emp emp=(Emp)biz.get(Emp.class,1);   %>   <%=emp.getEmpName() %> </body>

这个代码只是一个例子而已,你可以写别样的代码。这样就算完成了Open Session In View 模式。

再总结一遍:

关于No Session的这个问题,有了六种的解决方案:

方案一
在biz层 把load 改成get
方案二
/* if (!Hibernate.isInitialized(obj)) {
Hibernate.initialize(obj);
}*/
方案 三 :在 映射文件中 ,类级别 <set> 中加上 lazy =“false”
方案四: 在biz 层 先用一道 需要的UI使用 到的属性 ,然后在biz关闭
方案五:把实体类 改成 用 final 修饰,我们知道,延迟加载的原因是 内存中 有代理对象 (其实是emp 类的子类),所以当我们设为 该类 不能 有子类
方案六:Open Session In View 模式。

在上面都已经用代码做例子了,够清楚了的。