hibernate延遲載入以及no-session

阿新 • • 發佈：2018-12-29

延遲載入：延遲載入（lazy load懶載入）是當在真正需要資料時，才執行SQL語句進行查詢，避免了無謂的效能開銷。

延遲載入分類：

01.類級別的查詢策略

02.一對多和多對多關聯的查詢策略

03.多對一關聯的查詢策略

類級別的查詢策略

1.類級別可選的檢索策略包括立即檢索和延遲檢索，預設為延遲檢索

1.1立即檢索：立即載入檢索方法指定的物件,立即傳送SQL
1.2 延遲檢索：延遲載入檢索方法制定的物件.在使用具體的屬性時，再進行載入，才傳送SQL

2.無論<class>元素的lazy屬性是true還是false，Session的get()方法及Query

的list()方法在類級別總是使用立即檢索策略

3.若<class>元素的lazy屬性為true或預設值，Session的load()方法不會執行查詢資料庫表的SELECT語句，僅返回代理類物件的例項，該代理類例項有如下特徵：

3.1 由Hibernate在執行時採用CGLIB工具動態生成3.2 Hibernate建立代理類例項時，僅初始化其OID屬性3.3在應用程式第一次訪問代理類例項的非OID屬性時，Hibernate會初始化代理類例項

3.4注意：類級別檢索策略僅適用於load()方法

(立即載入，延遲載入等)檢索，通過set元素的lazy屬性設定。

01.一對多或者多對多檢索策略由

lazy和fetch共同確定

Lazy：決定關聯物件初始化時機

Fetch：決定SQL語句構建形式

02.fetch取值

Join：迫切左外連線

Select：多條簡單SQL（預設值）

Subselect：子查詢

03.fetch和lazy組合

解析：fetch=”join” lazy會被忽略，迫切左外連線的立即檢索

Fetch=”select” 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()會忽略對映檔案配置的左外連線查詢，此時lazy屬性重新生效。

具體案例

首先我們用的hibernate.hbm.xml都是一個的直接上傳一個就ok. 連線資料庫對應哪個包下仔細看一下。

<?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>

        <property name="myeclipse.connection.profile">JDBC for MySQL</property>

        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="connection.url">jdbc:mysql://localhost:3306/book</property>

        <property name="connection.username">root</property>

        <property name="connection.password"></property>

        <property name="hibernate.show_sql">true</property>

        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.format_sql">true</property>
        <!–生成特定資料庫sql–>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!–thread指定當前執行緒來跟蹤管理–>
        <property name="current_session_context_class">thread</property>


        <mapping resource="Dog.xml"></mapping>

    </session-factory>
-->

    <session-factory>
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">sll</property>
        <property name="connection.password">sll</property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>

<property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>

<property name="hbm2ddl.auto">update</property>
        <property name="connection.autocommit">true</property>
     <!--   <mapping resource="cn/happy/hibernate01/Cat.hbm.xml"/>
        <mapping resource="cn/happy/hibernate02/Dept.hbm.xml"/>-->
     <!--   <mapping resource="cn/happy/hibernate03hql/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate04pagelist/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate06mapping/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate06mapping/Dept.hbm.xml"/>

        <mapping resource="cn/happy/hibernate07onttomany/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate07onttomany/Dept.hbm.xml"/>
-->
       <!-- <mapping resource="cn/happy/hibernate08save/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate08save/Dept.hbm.xml"/>

      <mapping resource="cn/happy/hibernate09manytomany/Employee.hbm.xml"/>
        <mapping resource="cn/happy/hibernate09manytomany/Project.hbm.xml"/>
        <mapping resource="cn/happy/hibernate11lazyLoad/Student.hbm.xml"/>-->
   <!--   <mapping resource="cn/happy/hibernate11lazyLoad/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate11lazyLoad/Dept.hbm.xml"/>-->
        <!--no-session-->
      <!--  <mapping resource="cn/happy/hibernate12nosession/Emp.hbm.xml"/>
        <mapping resource="cn/happy/hibernate12nosession/Dept.hbm.xml"/>
-->
        <mapping resource="cn/happy/hibernate10opensessioninview/Student.hbm.xml"/>
        <mapping class="cn.happy.hibernate13zj.Dept"></mapping>
        <mapping class="cn.happy.hibernate14onetoone.Humen"></mapping>
        <mapping class="cn.happy.hibernate14onetoone.Card"></mapping>
    </session-factory>
</hibernate-configuration>

然後因為這個沒有用到註解所以我們需要小配置

首先我們看一下實體類。

package cn.happy.hibernate11lazyLoad;

import java.util.Date;

/**
 * Created by linlin on 2017/10/9.
 */
public class Student {
    private Integer stuno;
    private String stuname;
    private Integer stuage;
    private Date studate;

    public Integer getStuno() {
        return stuno;
    }

    public void setStuno(Integer stuno) {
        this.stuno = stuno;
    }

    public String getStuname() {
        return stuname;
    }

    public void setStuname(String stuname) {
        this.stuname = stuname;
    }

    public Integer getStuage() {
        return stuage;
    }

    public void setStuage(Integer stuage) {
        this.stuage = stuage;
    }

    public Date getStudate() {
        return studate;
    }

    public void setStudate(Date studate) {
        this.studate = studate;
    }
}

每個案例也就那幾步

小配置：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.happy.hibernate11lazyLoad">
    <class name="Student" table="StudentNew" schema="sll"  lazy="true">
        <id name="stuno" column="stuno">
           <generator class="native"></generator>
        </id>
        <property name="stuname" />
       <property name="stuage"/>
        <property name="studate"/>
    </class>
</hibernate-mapping>

測試類：

package cn.happy.test;


import cn.happy.hibernate11lazyLoad.Dept;
import cn.happy.hibernate11lazyLoad.Emp;
import cn.happy.hibernate11lazyLoad.Student;
import cn.happy.hibernate12nosession.biz.HibernateBiz;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Before;
import org.junit.Test;

import java.util.List;
import java.util.Set;

/**
 * Created by linlin on 2017/9/22.
 */
public class test1009 {
    Configuration cfg;
    Transaction tx;
    Session session;
    SessionFactory factory;

    @Before
    public void myBefore() {
        //建立配置物件
        cfg = new Configuration().configure("Hibernate.cfg.xml");
        //根據配置物件建立SessionFactory
        factory = cfg.buildSessionFactory();
        //根據SessionFactory建立Session
        session = factory.openSession();
        //在Session建立後開啟事務
        tx = session.beginTransaction();
    }


    @Test
    public void testmanyToOne() {
        Dept dept = session.get(Dept.class, 14);
        Set<Emp> emps = dept.getEmps();
        emps.size();
    }

    @Test
    public void testmanyToOne0() {
        Student student = session.load(Student.class, 1);
    }



}

這裡下面的方法是上面測試

下面這個是實體類和小配置是上面的方法

package cn.happy.hibernate11lazyLoad;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by linlin on 2017/9/24.
 */
public class Dept {
    private Integer deptno;
    private String deptname;

   private Set<Emp> emps=new HashSet<Emp>();

    public Set<Emp> getEmps() {
        return emps;
    }

    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

    public Dept() {
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }

    public String getDeptname() {
        return deptname;
    }

    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }
}

package cn.happy.hibernate11lazyLoad;

/**
 * Created by linlin on 2017/9/24.
 */
public class Emp {
    private Integer empno;
    private String ename;

   private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }
}

小配置：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.happy.hibernate08save">
    <class name="cn.happy.hibernate11lazyLoad.Dept" table="Dept" schema="sll">
        <id name="deptno" column="deptno">
            <generator class="native"/>
        </id>
        <property name="deptname" column="deptname"/>
        <set name="emps" lazy="false" fetch="join">
            <key column="deptno"/>
            <one-to-many class="Emp"/>
        </set>
    </class>


</hibernate-mapping>

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.happy.hibernate08save">
    <class name="cn.happy.hibernate11lazyLoad.Emp" table="Emp" schema="sll">
        <id name="empno" column="empno">
            <generator class="native"/>
        </id>
        <property name="ename" column="enmae"/>
        <many-to-one name="dept" column="deptno" class="Dept"></many-to-one>
    </class>


</hibernate-mapping>

上面是延遲載入的案例

下面是no-session

biz:

package cn.happy.hibernate12nosession.biz;

import cn.happy.hibernate12nosession.Emp;
import cn.happy.hibernate12nosession.dao.HibernateDAO;
import cn.happy.hibernate12nosession.util.HibernateUtil;
import org.hibernate.Hibernate;
import org.hibernate.Transaction;

import java.io.Serializable;

/**
 * Created by linlin on 2017/10/9.
 */
public class HibernateBiz {

    HibernateDAO dao=new HibernateDAO();
    public Object get(Class clazz, Serializable id) {
        Transaction tx = HibernateUtil.currentSession().beginTransaction();
        Object obj= dao.get(clazz, id);
       /* Emp emp=(Emp)obj;
        emp.getEname();*/
       if(!Hibernate.isInitialized(obj)){
           Hibernate.initialize(obj);
       }
        System.out.println("==============================================");
        tx.commit();
        HibernateUtil.closeSession();
        return obj;
    }
}

dao:

package cn.happy.hibernate12nosession.dao;



import cn.happy.hibernate10opensessioninview.util.HibernateUtil;

import java.io.Serializable;

/**
 * Created by linlin on 2017/10/9.
 */
public class HibernateDAO {

    public Object get(Class clazz, Serializable id) {
Object result= HibernateUtil.getSession().load(clazz,id);
return result;

    }
}

util:

package cn.happy.hibernate12nosession.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Created by linlin on 2017/10/6.
 */
public class HibernateUtil {
    //getCurrentSession()底層實現原理
    //ThreadLocal變數
    public static final ThreadLocal<Session> threadTL=new ThreadLocal<Session>();

    //我想直接呼叫一個方法，獲取Session
    //定義一個sessionFactory物件
    private static SessionFactory factory;
    private static Configuration cfg;
    static{
        cfg=new Configuration().configure();
        factory=cfg.buildSessionFactory();
    }
    //提供一個靜態方法
    public static Session currentSession(){
        Session session=threadTL.get();
        if(session==null){  //當前執行緒中沒有session物件
            session=factory.openSession();
            threadTL.set(session);
        }
        return session;

    }
    //關閉session
    public static void closeSession(){
        //獲取執行緒中的session
        Session session = threadTL.get();
        if (session!=null) {
            threadTL.set(null);
            session.close();
        }
    }

}

Dept Emp和上面的一樣的

測試類

package cn.happy.test;



import cn.happy.hibernate12nosession.Emp;
import cn.happy.hibernate12nosession.biz.HibernateBiz;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Before;
import org.junit.Test;

import java.util.Set;

/**
 * Created by linlin on 2017/9/22.
 */
public class test1009_01 {
    Configuration cfg;
    Transaction tx;
    Session session;
    SessionFactory factory;

    @Before
    public void myBefore() {
        //建立配置物件
        cfg = new Configuration().configure("Hibernate.cfg.xml");
        //根據配置物件建立SessionFactory
        factory = cfg.buildSessionFactory();
        //根據SessionFactory建立Session
        session = factory.openSession();
        //在Session建立後開啟事務
        tx = session.beginTransaction();
    }



    //no-session
    @Test
    public void loadGetTest() {
        HibernateBiz biz = new HibernateBiz();
       Emp emp = (Emp) biz.get(Emp.class, 1);
        System.out.println(emp.getEname());
    }
}

hibernate延遲載入以及no-session

延遲載入：延遲載入（lazy load懶載入）是當在真正需要資料時，才執行SQL語句進行查詢，避免了無謂的效能開銷。延遲載入分類： 01.類級別的查詢策略 02.一對多和多對多關聯的查詢策略 03.多對一關聯的查詢策略類級別的查詢策略 1.類級別

解決hibernate懶載入問題No session的問題

<filter> <filter-name>openSessionInViewFilter</filter-name> <filter-class>org.springframewo

hibernate延遲載入和session關閉問題

1.關閉延遲載入特性 2.在session關閉之前先獲取需要查詢的資料，可以使用工具方法Hibernate.isInitialized()判斷物件是否被載入，如果沒有被載入則可以使用Hibernate.initialize()方法載入物件。使用攔截器或過濾器延長Session的生命週期直到

hibernate的延遲載入及其與session關閉的矛盾

延遲載入就是並不是在讀取的時候就把資料載入進來，而是等到使用時再載入。那麼Hibernate是怎麼知道使用者在什麼時候使用資料了呢？又是如何載入資料呢？其實很簡單，它使用了代理機制。返回給使用者的並不是實體本身，而是實體物件的代理。代理物件在使用者呼叫g

Hibernate延遲載入(查詢優化)，關聯級別延遲載入優化策略

1. 類級別延遲載入：類級別使用延時載入，可以在class標籤上修改是否使用延遲載入 <class name="com.ssh.domain.Customer" table="cst_customer"> 2 關聯級別延遲載入：預設使用到的時候才進行查詢()

hibernate延遲載入(get和load的區別)

在hibernate中我們知道如果要從資料庫中得到一個物件，通常有兩種方式，一種是通過session.get()方法，另一種就是通過session.load()方法，然後其實這兩種方法在獲得一個實體物件時是有區別的，在查詢效能上兩者是不同的。一.load載入方式當使用

7.Hibernate 延遲載入&立即載入

延遲載入的好處 1.降低了記憶體的開銷，在用到某些資料的時候才會到資料中進行查詢。 2.提高了程式執行效能。注：如果session被關閉了，而你又想用到某些資料，這個時候使用延遲載入會出錯；需要立即

hibernate 延遲載入 load和get方法

延遲載入延遲載入：當hibernate從資料庫中載入某個物件時，不載入關聯的物件，而只是生成了代理物件。使用session中的load的方法(在沒有改變lazy屬性，屬性值為true的情況下)獲取到的也是代理物件。立即載入：當Hibernat

Hibernate延遲載入問題

Hibernate延遲載入是專案中非常常用的技術。通過使用Hibernate延遲載入機制可以在載入資料是不必載入全部資料，而是隻載入我們需要的那部分，其餘部分在需要使用時才從資料庫裝載，以此來減少資

hibernate延遲載入（load、get區別）

由於Spring控制的Hibernate的生命週期只針對資料層和服務層，而未管理到表現層，所以在表現層使用延時載入會出現the owning Session was closed或者no session or session was closed的異常資訊。針對這一點，可以通

SSH整合——Hibernate延遲載入引發的問題

這裡就是因為一開始載入Employee集合的時候，因為department屬性未被使用，所以採用了延遲載入。當在jsp頁面遍歷Employee集合的時候，此時就用到了department屬性，但是因為這裡採用的是getHibernateTemplate(),

hibernate 延遲載入與動態代理

Hibernae 的延遲載入是一個非常常用的技術，實體的集合屬性預設會被延遲載入，實體所關聯的實體預設也會被延遲載入。Hibernate 通過這種延遲載入來降低系統的記憶體開銷，從而保證 Hibernate 的執行效能。下面先來剖析 Hibernate 延遲載入的“祕

解決Quartz定時器中查詢懶載入資料no session的問題

相信大家在web開發過程中一定遇到過一種情況，Class班級類一對多關聯一個Student學生類，所以為了效能考慮，配置一個lazy-init=true，然後在前臺頁面需要訪問懶載入資料時需要額外配置一個OpenSessionInViewFilter,但是可能並

hibernate延遲載入

在hibernate中我們知道如果要從資料庫中得到一個物件，通常有兩種方式，一種是通過session.get()方法，另一種就是通過session.load()方法，然後其實這兩種方法在獲得一個實體物件時是有區別的，在查詢效能上兩者是不同的。一.load載入方式當使用load方法來得到一個物件時，

hibernate延遲載入機制——get和load原理

在hibernate中我們知道如果要從資料庫中得到一個物件，通常有兩種方式，一種是通過session.get()方法，另一種就是通過session.load()方法，然後其實這兩種方法在獲得一個實體物件時是有區別的，在查詢效能上兩者是不同的。一.load載入方式當

使用clone解決hibernate+spring整合中的延遲載入問題及分析(no session or session was closed)

首先說明一下，hibernate的延遲載入特性(lazy)。所謂的延遲載入就是當真正需要查詢資料時才執行資料載入操作。因為hibernate當中支援實體物件，外來鍵會與實體物件關聯起來。如果沒有這一特性，當查詢某一個含有外來鍵的實體物件時，hibernate會把其他實體物件的

failed to lazily initialize a collection of role: no session or session was closed (Hibernate) 解決方法（延遲載入問題）

在學著編寫OA 許可權管理時，在jsp 頁面中通過已取得的父模組來獲取該模組的所有子模組 JSP 程式碼片段： <c:forEach items="${modules}" var="module"> <c:forEach ite

fastjson序列化hibernate代理和延遲載入物件出現no session異常的解決辦法

fastjson序列化hibernate代理和延遲載入物件出現org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.eecn.ware

SSH:hibernate懶載入導致的no Session

在hibernate中,我們經常會設定兩個實體之間的關係為 <one-to-one> <many-to-many> <one to many> 用來描述兩張表之間的關係,如一個員工有多種職務,而一個職務由多個員工擔任,我們在查詢員工的時候,需

使用SSH框架進行開發的時候,由於延遲載入引起的no Session錯誤解決方法

問題產生的原因當我們進行多表查詢的時候,連線的表往往會採用延遲載入的策略,我們的事物管理往往會放在Service層,當事物提交Session關閉後,在Action才會用到連線表中的資料,這時候再嘗試呼叫Session,獲取資料.但是Session已經關閉了,自然就會報出no s

hibernate延遲載入以及no-session

類級別的查詢策略

相關推薦