2. 程式人生 > >hibernate快取機制詳細分析 複製程式碼

hibernate快取機制詳細分析 複製程式碼

阿新 • • 發佈：2019-02-19 
您可以通過點選 右下角 的按鈕 來對文章內容作出評價, 也可以通過左下方的 關注按鈕 來關注我的部落格的最新動態。 

如果文章內容對您有幫助, 不要忘記點選右下角的 推薦按鈕 來支援一下哦   

如果您對文章內容有任何疑問, 可以通過評論或發郵件的方式聯絡我: [email protected]  / [email protected]

如果需要轉載，請註明出處，謝謝！！
複製程式碼

在本篇隨筆裡將會分析一下hibernate的快取機制，包括一級快取(session級別)、二級快取(sessionFactory級別)以及查詢快取，當然還要討論下我們的N+1的問題。

隨筆雖長，但我相信看完的朋友絕對能對hibernate的 N+1問題以及快取有更深的瞭解。

一、N+1問題

首先我們來探討一下N+1的問題，我們先通過一個例子來看一下，什麼是N+1問題：

list()獲得物件：

複製程式碼 
　　　　　　　/**
             * 此時會發出一條sql，將30個學生全部查詢出來
             */
            List<Student> ls = (List<Student>)session.createQuery("from Student")
                                .setFirstResult(0).setMaxResults(30).list();
            Iterator
 
<Student> stus = ls.iterator();
            for(;stus.hasNext();)
            {
                Student stu = (Student)stus.next();
                System.out.println(stu.getName());
            }
複製程式碼

如果通過list()方法來獲得物件，毫無疑問，hibernate會發出一條sql語句，將所有的物件查詢出來，這點相信大家都能理解

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

那麼，我們再來看看iterator()這種情況

iterator()獲得物件

複製程式碼 
　　　　　　　/**
             * 如果使用iterator方法返回列表，對於hibernate而言，它僅僅只是發出取id列表的sql
             * 在查詢相應的具體的某個學生資訊時，會發出相應的SQL去取學生資訊
             * 這就是典型的N+1問題
             * 存在iterator的原因是，有可能會在一個session中查詢兩次資料，如果使用list每一次都會把所有的物件查詢上來
             * 而是要iterator僅僅只會查詢id，此時所有的物件已經儲存在一級快取(session的快取)中，可以直接獲取
             */
            Iterator<Student> stus = (Iterator<Student>)session.createQuery("from Student")
                                .setFirstResult(0).setMaxResults(30).iterate();
            for(;stus.hasNext();)
            {
                Student stu = (Student)stus.next();
                System.out.println(stu.getName());
            }
複製程式碼

在執行完上述的測試用例後，我們來看看控制檯的輸出，看會發出多少條 sql 語句：

複製程式碼 
Hibernate: select student0_.id as col_0_0_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
沈凡
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
王志名
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
葉敦
.........
複製程式碼

我們看到，當如果通過iterator()方法來獲得我們物件的時候，hibernate首先會發出1條sql去查詢出所有物件的 id 值，當我們如果需要查詢到某個物件的具體資訊的時候，hibernate此時會根據查詢出來的 id 值再發sql語句去從資料庫中查詢物件的資訊，這就是典型的 N+1 的問題。

那麼這種 N+1 問題我們如何解決呢，其實我們只需要使用 list() 方法來獲得物件即可。但是既然可以通過 list() 我們就不會出現 N+1的問題，那麼我們為什麼還要保留 iterator()這種形式呢？我們考慮這樣一種情況，如果我們需要在一個session當中要兩次查詢出很多物件，此時我們如果寫兩條 list()時，hibernate此時會發出兩條 sql 語句，而且這兩條語句是一樣的，但是我們如果第一條語句使用 list()，而第二條語句使用 iterator()的話，此時我們也會發兩條sql語句，但是第二條語句只會將查詢出物件的id，所以相對應取出所有的物件而已，顯然這樣可以節省記憶體，而如果再要獲取物件的時候，因為第一條語句已經將物件都查詢出來了，此時會將物件儲存到session的一級快取中去，所以再次查詢時，就會首先去快取中查詢，如果找到，則不發sql語句了。這裡就牽涉到了接下來這個概念:hibernate的一級快取。

二、一級快取(session級別)

我們來看看hibernate提供的一級快取：

複製程式碼 
　　　　　　　/**
             * 此時會發出一條sql，將所有學生全部查詢出來，並放到session的一級快取當中
             * 當再次查詢學生資訊時，會首先去快取中看是否存在，如果不存在，再去資料庫中查詢
             * 這就是hibernate的一級快取(session快取)
             */
            List<Student> stus = (List<Student>)session.createQuery("from Student")
                                    .setFirstResult(0).setMaxResults(30).list();
            Student stu = (Student)session.load(Student.class, 1);
複製程式碼

我們來看看控制檯輸出：

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

我們看到此時hibernate僅僅只會發出一條 sql 語句，因為第一行程式碼就會將整個的物件查詢出來，放到session的一級快取中去，當我如果需要再次查詢學生物件時，此時首先會去快取中看是否存在該物件，如果存在，則直接從快取中取出，就不會再發sql了，但是要注意一點：hibernate的一級快取是session級別的，所以如果session關閉後，快取就沒了，此時就會再次發sql去查資料庫。

複製程式碼 
　　　　　try
        {
            session = HibernateUtil.openSession();
            
            /**
             * 此時會發出一條sql，將所有學生全部查詢出來，並放到session的一級快取當中
             * 當再次查詢學生資訊時，會首先去快取中看是否存在，如果不存在，再去資料庫中查詢
             * 這就是hibernate的一級快取(session快取)
             */
            List<Student> stus = (List<Student>)session.createQuery("from Student")
                                    .setFirstResult(0).setMaxResults(30).list();
            Student stu = (Student)session.load(Student.class, 1);
            System.out.println(stu.getName() + "-----------");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        /**
         * 當session關閉以後，session的一級快取也就沒有了，這時就又會去資料庫中查詢
         */
        session = HibernateUtil.openSession();
        Student stu = (Student)session.load(Student.class, 1);
        System.out.println(stu.getName() + "-----------");
複製程式碼 複製程式碼 
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?

Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
複製程式碼

我們看到此時會發出兩條sql語句，因為session關閉以後，一級快取就不存在了，所以如果再查詢的時候，就會再發sql。要解決這種問題，我們應該怎麼做呢？這就要我們來配置hibernate的二級快取了，也就是sessionFactory級別的快取。

三、二級快取(sessionFactory級別)

使用hibernate二級快取，我們首先需要對其進行配置，配置步驟如下：

1.hibernate並沒有提供相應的二級快取的元件，所以需要加入額外的二級快取包，常用的二級快取包是EHcache。這個我們在下載好的hibernate的lib->optional->ehcache下可以找到(我這裡使用的hibernate4.1.7版本)，然後將裡面的幾個jar包匯入即可。

2.在hibernate.cfg.xml配置檔案中配置我們二級快取的一些屬性：

　　　　 <!-- 開啟二級快取 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!-- 二級快取的提供類 在hibernate4.0版本以後我們都是配置這個屬性來指定二級快取的提供類-->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
        <!-- 二級快取配置檔案的位置 -->
        <property name="hibernate.cache.provider_configuration_file_resource_path">ehcache.xml</property>

我這裡使用的是hibernate4.1.7版本，如果是使用hibernate3的版本的話，那麼二級快取的提供類則要配置成這個：

<!--這個類在4.0版本以後已經不建議被使用了-->
<property name="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</property>

3.配置hibernate的二級快取是通過使用 ehcache的快取包，所以我們需要建立一個 ehcache.xml 的配置檔案，來配置我們的快取資訊，將其放到專案根目錄下

複製程式碼 
<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
　　
　　<!--指定二級快取存放在磁碟上的位置-->
    <diskStore path="user.dir"/>　　

　　<!--我們可以給每個實體類指定一個對應的快取，如果沒有匹配到該類，則使用這個預設的快取配置-->
    <defaultCache
        maxElementsInMemory="10000"　　//在記憶體中存放的最大物件數
        eternal="false"　　　　　　　　　//是否永久儲存快取，設定成false
        timeToIdleSeconds="120"　　　　
        timeToLiveSeconds="120"　　　　
        overflowToDisk="true"　　　　　//如果物件數量超過記憶體中最大的數，是否將其儲存到磁碟中，設定成true
        />
　　
　　<!--

　　　　1、timeToLiveSeconds的定義是：以建立時間為基準開始計算的超時時長；
　　　　2、timeToIdleSeconds的定義是：在建立時間和最近訪問時間中取出離現在最近的時間作為基準計算的超時時長；
　　　　3、如果僅設定了timeToLiveSeconds，則該物件的超時時間=建立時間+timeToLiveSeconds，假設為A；
　　　　4、如果沒設定timeToLiveSeconds，則該物件的超時時間=max(建立時間，最近訪問時間)+timeToIdleSeconds，假設為B；
　　　　5、如果兩者都設定了，則取出A、B最少的值，即min(A,B)，表示只要有一個超時成立即算超時。

　　-->

　　<!--可以給每個實體類指定一個配置檔案，通過name屬性指定，要使用類的全名-->
    <cache name="com.xiaoluo.bean.Student"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->


</ehcache>
複製程式碼

4.開啟我們的二級快取

①如果使用xml配置，我們需要在 Student.hbm.xml 中加上一下配置：

複製程式碼 
<hibernate-mapping package="com.xiaoluo.bean">
    <class name="Student" table="t_student">
        <!-- 二級快取一般設定為只讀的 -->
        <cache usage="read-only"/>
        <id name="id" type="int" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="string"></property>
        <property name="sex" column="sex" type="string"></property>
        <many-to-one name="room" column="rid" fetch="join"></many-to-one>
    </class>
</hibernate-mapping>
複製程式碼

二級快取的使用策略一般有這幾種：read-only、nonstrict-read-write、read-write、transactional。注意：我們通常使用二級快取都是將其配置成 read-only ，即我們應當在那些不需要進行修改的實體類上使用二級快取，否則如果對快取進行讀寫的話，效能會變差，這樣設定快取就失去了意義。

②如果使用annotation配置，我們需要在Student這個類上加上這樣一個註解：

複製程式碼 
@Entity
@Table(name="t_student")
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY)　　//　　表示開啟二級快取，並使用read-only策略
public class Student
{
    private int id;
    private String name;
    private String sex;
    private Classroom room;
    .......
}
複製程式碼

這樣我們的二級快取配置就算完成了，接下來我們來通過測試用例測試下我們的二級快取是否起作用

①二級快取是sessionFactory級別的快取

TestCase1：

複製程式碼 
public class TestSecondCache
{
    @Test
    public void testCache1()
    {
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();

            Student stu = (Student) session.load(Student.class, 1);
            System.out.println(stu.getName() + "-----------");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        try
        {
            /**
             * 即使當session關閉以後，因為配置了二級快取，而二級快取是sessionFactory級別的，所以會從快取中取出該資料
             * 只會發出一條sql語句
             */
            session = HibernateUtil.openSession();
            Student stu = (Student) session.load(Student.class, 1);
            System.out.println(stu.getName() + "-----------");
            /**
             * 因為設定了二級快取為read-only，所以不能對其進行修改
             */
            session.beginTransaction();
            stu.setName("aaa");
            session.getTransaction().commit();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        finally
        {
            HibernateUtil.close(session);
        }
    }
複製程式碼 
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
aaa-----------
aaa-----------

因為二級快取是sessionFactory級別的快取，我們看到，在配置了二級快取以後，當我們session關閉以後，我們再去查詢物件的時候，此時hibernate首先會去二級快取中查詢是否有該物件，有就不會再發sql了。

②二級快取快取的僅僅是物件，如果查詢出來的是物件的一些屬性，則不會被加到快取中去

TestCase2：

複製程式碼 
　　@Test
    public void testCache2()
    {
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();

            /**
             * 注意：二級快取中快取的僅僅是物件，而下面這裡只儲存了姓名和性別兩個欄位，所以 不會被載入到二級快取裡面
             */
            List<Object[]> ls = (List<Object[]>) session
                    .createQuery("select stu.name, stu.sex from Student stu")
                    .setFirstResult(0).setMaxResults(30).list();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        try
        {
            /**
             * 由於二級快取快取的是物件，所以此時會發出兩條sql
             */
            session = HibernateUtil.openSession();
            Student stu = (Student) session.load(Student.class, 1);
            System.out.println(stu);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
複製程式碼 
Hibernate: select student0_.name as col_0_0_, student0_.sex as col_1_0_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?

我們看到這個測試用例，如果我們只是取出物件的一些屬性的話，則不會將其儲存到二級快取中去，因為二級快取快取的僅僅是物件。

③通過二級快取來解決 N+1 的問題

TestCase3：

複製程式碼 
　　@Test
    public void testCache3()
    {
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();
            /**
             * 將查詢出來的Student物件快取到二級快取中去
             */
            List<Student> stus = (List<Student>) session.createQuery(
                    "select stu from Student stu").list();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        try
        {
            /**
             * 由於學生的物件已經快取在二級快取中了，此時再使用iterate來獲取物件的時候，首先會通過一條
             * 取id的語句，然後在獲取物件時去二級快取中，如果發現就不會再發SQL，這樣也就解決了N+1問題 
             * 而且記憶體佔用也不多
             */
            session = HibernateUtil.openSession();
            Iterator<Student> iterator = session.createQuery("from Student")
                    .iterate();
            for (; iterator.hasNext();)
            {
                Student stu = (Student) iterator.next();
                System.out.println(stu.getName());
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
複製程式碼

當我們如果需要查詢出兩次物件的時候，可以使用二級快取來解決N+1的問題。

④二級快取會快取 hql 語句嗎？

TestCase4：

複製程式碼 
　　@Test
    public void testCache4()
    {
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student")
                    .setFirstResult(0).setMaxResults(50).list();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        try
        {
            /**
             * 使用List會發出兩條一模一樣的sql，此時如果希望不發sql就需要使用查詢快取
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student")
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stu = ls.iterator();
            for(;stu.hasNext();)
            {
                Student student = stu.next();
                System.out.println(student.getName());
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            HibernateUtil.close(session);
        }
    }
複製程式碼 
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?

我們看到，當我們如果通過 list() 去查詢兩次物件時，二級快取雖然會快取查詢出來的物件，但是我們看到發出了兩條相同的查詢語句，這是因為二級快取不會快取我們的hql查詢語句，要想解決這個問題，我們就要配置我們的查詢快取了。

四、查詢快取(sessionFactory級別)

我們如果要配置查詢快取，只需要在hibernate.cfg.xml中加入一條配置即可：

　　　　　<!-- 開啟查詢快取 -->
        <property name="hibernate.cache.use_query_cache">true</property>

然後我們如果在查詢hql語句時要使用查詢快取，就需要在查詢語句後面設定這樣一個方法:

List<Student> ls = session.createQuery("from Student where name like ?")
                    .setCacheable(true)　　//開啟查詢快取，查詢快取也是SessionFactory級別的快取
                    .setParameter(0, "%王%")
                    .setFirstResult(0).setMaxResults(50).list();

如果是在annotation中，我們還需要在這個類上加上這樣一個註解：@Cacheable

接下來我們來通過測試用例來看看我們的查詢快取

①查詢快取也是sessionFactory級別的快取

TestCase1：

複製程式碼 
　　@Test
    public void test2() {
        Session session = null;
        try {
            /**
             * 此時會發出一條sql取出所有的學生資訊
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student")
                    .setCacheable(true)  //開啟查詢快取,查詢快取也是sessionFactory級別的快取
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
        try {
            /**
             * 此時會發出一條sql取出所有的學生資訊
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student")
                    .setCacheable(true)  //開啟查詢快取,查詢快取也是sessionFactory級別的快取
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
    }
複製程式碼 
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?

我們看到，此時如果我們發出兩條相同的語句，hibernate也只會發出一條sql，因為已經開啟了查詢快取了，並且查詢快取也是sessionFactory級別的

②只有當 HQL 查詢語句完全相同時，連引數設定都要相同，此時查詢快取才有效

TestCase2：

複製程式碼 
　　@Test
    public void test3() {
        Session session = null;
        try {
            /**
             * 此時會發出一條sql取出所有的學生資訊
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student where name like ?")
                    .setCacheable(true)//開啟查詢快取，查詢快取也是SessionFactory級別的快取
                    .setParameter(0, "%王%")
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
        session = null;
        try {
            /**
             * 此時會發出一條sql取出所有的學生資訊
             */
            session = HibernateUtil.openSession();
            /**
             * 只有當HQL完全相同的時候，連引數都要相同，查詢快取才有效
             */
//            List<Student> ls = session.createQuery("from Student where name like ?")
//                    .setCacheable(true)//開啟查詢快取，查詢快取也是SessionFactory級別的快取
//                    .setParameter(0, "%王%")
//                    .setFirstResult(0).setMaxResults(50).list();
            List<Student> ls = session.createQuery("from Student where name like ?")
                    .setCacheable(true)//開啟查詢快取，查詢快取也是SessionFactory級別的快取
                    .setParameter(0, "%張%")
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
    }
複製程式碼 
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?

我們看到，如果我們的hql查詢語句不同的話，我們的查詢快取也沒有作用

③查詢快取也能引起 N+1 的問題

查詢快取也能引起 N+1 的問題，我們這裡首先先將 Student 物件上的二級快取先註釋掉：

　　　　　<!-- 二級快取一般設定為只讀的 -->
        <!--　　<cache usage="read-only"/>　　-->

TestCase4：

複製程式碼 
　　@Test
    public void test4() {
        Session session = null;
        try {
            /**
             * 查詢快取快取的不是物件而是id
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student where name like ?")
                    .setCacheable(true)//開啟查詢快取，查詢快取也是SessionFactory級別的快取
                    .setParameter(0, "%王%")
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
        
        session = null;
        try {
            /**
             * 查詢快取快取的是id，此時由於在快取中已經存在了這樣的一組學生資料，但是僅僅只是快取了
             * id，所以此處會發出大量的sql語句根據id取物件，這也是發現N+1問題的第二個原因
             * 所以如果使用查詢快取必須開啟二級快取
             */
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student where name like ?")
                    .setCacheable(true)//開啟查詢快取，查詢快取也是SessionFactory級別的快取
                    .setParameter(0, "%王%")
                    .setFirstResult(0).setMaxResults(50).list();
            Iterator<Student> stus = ls.iterator();
            for(;stus.hasNext();) {
                Student stu = stus.next();
                System.out.println(stu.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            HibernateUtil.close(session);
        }
    }
複製程式碼 複製程式碼 
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?

Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?

.........................
複製程式碼

我們看到，當我們將二級快取註釋掉以後，在使用查詢快取時，也會出現 N+1 的問題，為什麼呢？

因為查詢快取快取的也僅僅是物件的id，所以第一條 sql 也是將物件的id都查詢出來，但是當我們後面如果要得到每個物件的資訊的時候，此時又會發sql語句去查詢，所以，如果要使用查詢快取，我們一定也要開啟我們的二級快取，這樣就不會出現 N+1 問題了

好了，整篇隨筆大概花費了2個小時來編寫，可以說將hibernate的 N+1 問題、一級快取、二級快取、查詢快取的概念以及可能出現的問題都分析了透，希望能對大家提供幫助！

相關推薦

hibernate快取機制詳細分析 複製程式碼

您可以通過點選 右下角 的按鈕 來對文章內容作出評價, 也可以通過左下方的 關注按鈕 來關注我的部落格的最新動態。 如果文章內容對您有幫助, 不要忘記點選右下角的 推薦按鈕 來支援一下哦 如果您對文章內容有任何疑問, 可以通過評論或發郵件的方式聯絡我: 5013

hibernate快取機制詳細分析(一級/二級/查詢快取)

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.n

hibernate緩存機制詳細分析

provide home property 指定 當我 seconds idle eat its 在本篇隨筆裏將會分析一下hibernate的緩存機制，包括一級緩存(session級別)、二級緩存(sessionFactory級別)以及查詢緩存，當然還要討論下我們的N+1的

(轉）hibernate緩存機制詳細分析

只需要 設置 use fetch 註意 文件 () tran enc 在本篇隨筆裏將會分析一下hibernate的緩存機制，包括一級緩存(session級別)、二級緩存(sessionFactory級別)以及查詢緩存，當然還要討論下我們的N+1的問題。 隨筆雖長，但我相信看

PHP 控制反轉與依賴注入詳細分析與程式碼實現

PHP有很多的設計模式，比如單例模式，訂閱模式，策略模式，工廠模式，觀察者模式，這些設計模式其實無非都是為了讓程式簡化，容易維護，模組間解耦。現在我們來講講PHP的另外一種設計模式，控制反轉/依賴注入，這兩者其實是同一個概念，只是凶不同的角度去解釋的而已。 依賴注入：是從需要實現的業務邏輯上面去

SSM中使用redis做中間快取，詳細註釋，程式碼可以執行

1.介紹 在開發中經常遇到大量的重複的，高併發的查詢，此時可以使用redis快取，將結果存入到redis中，當用戶發起查詢請求時，先在redis中查詢結果，沒有命中再去訪問資料庫。這樣可以大大減少資料庫壓力。 2.結構目錄 我的專案可以正常執行，程式碼都會給出來，所以程式碼都是可以跑的

垃圾回收機制詳細分析

垃圾回收機制是 Java 非常重要的特性之一，也是面試題的常客。它讓開發者無需關注空間的建立和釋放，而是以守護程序的形式在後臺自動回收垃圾。這樣做不僅提高了開發效率，更改善了記憶體的使用狀況。 今天本文來對垃圾回收機制進行講解，主要涉及下面幾個問題： 什麼是堆記憶體？

Hibernate快取機制

快取：為了降低應用程式對物理資料來源訪問的頻次，從而提高應用程式的執行效能。 快取的工作原理： 物理資料來源——>（資料）快取——>（資料）記憶體 在應用程式中首先會選擇在快取中讀取資料，如果快取中沒有再選擇在資料庫中讀取並把讀取的資料放到快取中；有點類似暫存器

hibernate快取機制簡述

快取的作用主要用來提高效能，可以簡單地理解成一個Map。使用快取涉及到三個操作：把資料放入快取（put）、從快取中獲取資料（get）、刪除快取中的無效資料（remove）。 一級快取，Session級共享（生命週期很短，一般在一個Http請求內）：        save

hibernate 快取機制

一級快取 1、當session的save()方法持久化一個customer物件時，customer物件被載入到session的快取中，以後即使應用程式中的引用變數不再引用customer物件，只要session的快取還沒有被清空，customer物件仍然處於生命週期中。 2

Hibernate旅程（八）Hibernate快取機制--二級快取

Hibernate二級級快取 上篇介紹了一級快取，主要是session快取，session生命週期結束，快取也就結束。二級快取相對於一級快取來說是一個範圍更廣闊一些，就比你住的地方周圍有多個小賣鋪（session快取），和一個大型超市，原料加工廠送貨的時候送小賣鋪一份的同時，必然送一份到超市。而給第二個小

Java的異常機制詳細分析

回到頂部 異常的概念 異常是程式中的一些錯誤，但並不是所有的錯誤都是異常，並且錯誤有時候是可以避免的。 比如說，你的程式碼少了一個分號，那麼執行出來結果是提示是錯誤java.lang.Error；如果你用System.out.println(11

hibernate快取機制-簡述

hibernate作為orm最優秀的框架之一，它的快取也是非常優秀的，比起其他orm框架，hibernate的快取機制顯得很複雜，如果長時間不使用，又忘記了,提到hibernate，我就只能想起hib

Hibernate旅程（七）Hibernate快取機制--一級快取

Hibernate一級快取 快取就是你去小賣鋪買東西，不用再去生產車間裡買東西，當小賣鋪倒閉了，也就是session快取生命週期結束。hibernate一級快取的宣告週期很短，和session的

網路接收資料快取機制的分析和改進

在非同步網路接收資料等場合，剝離資料接收和資料快取的對於提高處理能力具有重要影響。相比之下，接收即處理的做法不能很好的適應高速資料吞吐。因為後者的處理如果稍有延遲，就會導致嚴重的資料堵塞或資料丟失。 下面以libuv接收UDP資料包加入快取、應用程式從快取提取資料的應用為

SSH：Hibernate框架（Hibernate快取機制及三種狀態）

一、why（為什麼要用Hibernate快取？） Hibernate是一個持久層框架，經常訪問物理資料庫。 為了降低應用程式對物理資料來源訪問的頻次，從而提高應用程式的執行效能。 快取內的資料是對物理資料來源中的資料的複製，應用程式在執行時從快取讀寫資料，在特定的時刻或事件會同步快取和物理資料來源的資料。

Hibernate之快取機制！！！！！！

快取： 　　是計算機領域的概念，它介於應用程式和永久性資料儲存源之間。 快取： 　　一般人的理解是在記憶體中的一塊空間，可以將二級快取配置到硬碟。用白話來說，就是一個儲存資料的容器。我們關注的是，哪些資料需要被放入二級快取。 快取作用： 　　降低應用程式直接讀寫資料庫的頻率，從而提高程式的執行效能。

MFC操作串列埠，詳細 複製程式碼（ActiveX控制元件和Windows API函式）

/******************************************************************* *******函式功能：開啟串列埠裝置連結 *******函式名稱：OpenComm *******輸入引數：無 *******輸出引數：無 ***

Rest Framework第六天-路飛學城專案分析、contentType元件、django快取機制、跨域問題

1 路飛學成專案分析     -主站         課程系列：             -所有課程（專題課，學位課）             -課程詳情             -視訊播放             -課程章節             -課程評論       

梳理hibernate篇-原理及快取機制

Hibernate工作原理  本文出自： http://www.cnblogs.com/bile/p/4030575.html  現在我們知道了一個概念Hibernate Session，只有處於Session管理下的POJO才具有持久化操作能力。當應用程式對於處於Sessi