在本篇隨筆裏將會分析一下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：

[email protected]
    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：

[email protected]
    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：

[email protected]
    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：

[email protected]
    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：

[email protected]
    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：

[email protected]
    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緩存機制詳細分析