2. 程式人生 > >hibernate--一級和二級快取（使用Ehcache）以及查詢快取

hibernate--一級和二級快取（使用Ehcache）以及查詢快取

阿新 • • 發佈：2019-02-03

有一下幾點需要理清才行：

一級快取是session快取 session關閉就小時

二級快取是sessionFactory級別的快取 一個應用程式只有一個 多個執行緒共享  不要把經常修改的物件放到二級快取中 二級快取中放一些查詢的物件

1 首先是在hibernate,cfg.xml檔案中進行配置：

新增下列配置項

                <property name="hibernate.cache.use_second_level_cache">true</property>
		<!-- 使用哪種快取提供的類 哪種快取 -->
		<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<!-- 使用查詢快取-->
		<property name="hibernate.cache.use_query_cache">true</property>
		<!-- ehcache.xml的配置檔案路徑 -->
		<property name="hibernate.cache.provider_configuration_file_resource_path">ehcache.xml</property>
在需要使用二級快取的物件配置檔案上： 
	<class name="Student" table="t_stu">
		<!--  <cache usage="read-only" /> -->
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 注意：version 一定要加在ID後面 property前面 -->
		<version name="version" />
		<property name="name" />
		<property name="sex" />
		<many-to-one name="classroom" column="cid" fetch="join" />
	</class>
ehcache.xml中的配置： 
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

<!-- 每一個獨立的cache可以單獨為不同的物件進行設定 如果找不到就用預設的cache-->
    <cache name="com.itany.model.Student"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />



2 N+1問題

 如果使用iterator返回列表 對於hibernate而言 
         它僅僅是查詢了id列表的SQL 在進行iterator迭代的時候 
         再會根據id一個個去資料庫查詢具體物件 因此發出多條SQL 這就是典型的N+1問題 避免它
         就是不使用iterator iterator存在的原因 
         使用的地方：
         因為有可能需要查詢2次 第一次list全部查詢出來 存在二級快取中 第二次 用Iterator資料庫查id，再根據ID從二級快取的物件中查詢更快

            session = HibernateUtil.openSession();
            Iterator<Student> it = session.createQuery("from Student").setFirstResult(0).setMaxResults(12).iterate();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
3  重要：二級快取快取的是物件　　查詢快取快取的是ＩＤ　這是兩種不同的快取  誰也不依賴誰　　 查詢快取也是sessionFactory級別的快取

     查詢快取是針對HQL語句的快取  查詢緩只快取ID 而不會快取物件
     1 但是使用查詢快取最好開啟二級快取　因為在查詢快取中查到ＩＤ後可以直接去
     二級快取中查詢　不然的話又是Ｎ＋１問題　多次根據查詢快取中的ＩＤ去資料庫查詢
     2 若打開了二級快取 但是沒有開啟查詢快取（HQL不一致、引數不一致、查詢快取沒開、
     setCacheable(true)沒寫等原因）那麼還是會直接從資料庫中查詢一次、
     因為需要藉助查詢快取查ID再到二級快取中查物件
     3 注意：load方式可以直接從二級快取中查物件 不必藉助查詢快取
     4如果取得只是某些屬性（而不是完整物件） 那麼不會進行二級快取見test04
     5 查詢快取 工作順序：如果正常開啟了查詢快取（HQL完全一致 且set(True)），先去查詢快取中查ID
          再根據查詢到的ID去二級快取中查物件 若此時二級快取打開了 那麼不會發SQL
         若二級快取沒開啟  那麼此時會再次根據查到的ID去資料庫中查詢

4 程式碼中使用查詢快取

 List<Object[]> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
5 此時關閉了二級快取（存物件）
    打開了查詢快取（存ID） 第二個人查詢快取只查到ID 會根據ID 去二級快取查物件  但是沒有  所以去資料庫查  發出大量SQL

6 查詢快取很少使用 因為很少ＨＱＬ完全一樣
          因為只要HQL語句不一樣 就不會開啟查詢快取 
          只有兩個完全一樣的 並且引數都一樣的 才能使用查詢快取

public class TestSecondCache
{
    /*
     * 重要：二級快取快取的是物件　　查詢快取快取的是ＩＤ　這是兩種不同的快取
     * 誰也不依賴誰　　
     * 1 但是使用查詢快取最好開啟二級快取　因為在查詢快取中查到ＩＤ後可以直接去
     * 二級快取中查詢　不然的話又是Ｎ＋１問題　多次根據查詢快取中的ＩＤ去資料庫查詢
     * 2 若打開了二級快取 但是沒有開啟查詢快取（HQL不一致、引數不一致、查詢快取沒開、
     * setCacheable(true)沒寫等原因）那麼還是會直接從資料庫中查詢一次、
     * 因為需要藉助查詢快取查ID再到二級快取中查物件
     * 3 注意：load方式可以直接從二級快取中查物件 不必藉助查詢快取
     * 
     * 如果取得只是某些屬性（而不是完整物件） 那麼不會進行二級快取見test04
     */
    
    @Test
    public void test01()
    {
        /*
         * 不可以快取 Ehcache是看SQL是否一樣
         */
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();
            Student s=(Student)session.load(Student.class,1);
            System.out.println(s.getName());
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        Session session2 = null;
        /*
         * 此時session已經關閉 但再次查詢 仍然可以不發SQL  二級快取起作用了
         */
        try
        {
            session2 = HibernateUtil.openSession();
            Student s2=(Student)session2.load(Student.class,1);//這種寫法 根據ID去二級快取中查詢
            System.out.println(s2.getName());
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session2)
                HibernateUtil.closeSession(session2);
        }
    }
    @Test
    public void test02()
    {
        /*
         * 
         */
        Session session = null;
        try
        {
            session = HibernateUtil.openSession();
            Student s=(Student)session.load(Student.class,1);
            System.out.println(s.getName());
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        Session session2 = null;
        Transaction trans=null;
        /*
         * 會報錯 因為二級快取 在Student上設定的是 read-only 因此不能寫入
         * 最好不要設定 read write因為hibernate要頻繁的加鎖 解鎖 影響效率 還不如不用二級快取
         */
        try
        {
            session2 = HibernateUtil.openSession();
            trans=session2.beginTransaction();
            Student s2=(Student)session2.load(Student.class,1);
            s2.setName("zhangasnsss");
            System.out.println(s2.getName());
            trans.commit();
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session2)
                HibernateUtil.closeSession(session2);
        }
    }
    @Test
    public void test03()
    {
        /*
         * 
         */
        Session session = null;
        Transaction trans = null;
        try
        {
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("from Student").list();
            Iterator<Student> it = ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        
        try
        {
            session = HibernateUtil.openSession();
            Student s=(Student)session.load(Student.class,1);
            System.out.println(s.getName());
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test04()
    {
        /*
         * 
         */
        Session session = null;
        Transaction trans = null;
        try
        {
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu.id,stu.name from Student stu").list();
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*
         * 以上程式碼僅僅去了id和name 而二級快取是快取物件的 所以上一段程式碼不會使用二級快取
         * 此時就會發出相應的SQL
         */
        try
        {
            session = HibernateUtil.openSession();
            Student s=(Student)session.load(Student.class,1);
            System.out.println(s.getName());
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test05()
    {
        /*
         * iterator 作用就是配合二級快取使用 最好
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu").list();
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /* 1條SQL
         * 由於學生的物件經過上面查詢物件之後 已經存在於二級快取之中
         * 此時正好直接使用iterator  首先會查詢通過1條取ID的語句  然後再獲取物件時候去二級快取中查詢
         * 有的話 直接用 不會產生N+1問題
         * 
         *    若沒二級快取 我們直接使用iterator會首先產生一條查ID的語句
         *    再在獲取物件的時候再去資料庫中取 那麼這是就會產生N+1問題
         */
        try
        {
            session = HibernateUtil.openSession();
            Iterator<Student> it = session.createQuery("from Student").iterate();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test06()
    {
        /*
         * 與上面一個幾乎一樣 區別在於iterator換成list() 
         * 雖然第一次已經二級快取了  但是不能決定我再去不去資料庫中查詢
         * 
         * 重要 ：如果希望第二次不發SQL 那就要使用查詢快取
         * 查詢快取是針對HQL語句的快取  查詢緩只快取ID 而不會快取物件
         */
        Session session = null;
        
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu").list();
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /* 1條SQL  和上一條一模一樣
         * 
         */
        try
        {
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu").list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test07()
    {
        /*
         * 設定了查詢快取為true
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu")
                .setCacheable(true).list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*0條SQL 
         * 
         */
        try
        {
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu")
                .setCacheable(true).list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test08()
    {
        /*
         * 此時無法使用查詢快取 查詢快取很少使用 因為很少ＨＱＬ完全一樣
         * 因為只要HQL語句不一樣 就不會開啟查詢快取 
         * 只有兩個完全一樣的 並且引數都一樣的 才能使用查詢快取
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*
         * 
         */
        try
        {
          //一條SQL
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%王%").list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test09()
    {
        /*
         * 此時關閉了二級快取（存物件）
         * 打開了查詢快取（存ID）
         * ！！！工作順序：如果正常開啟了查詢快取（HQL完全一致 且set(True)），先去查詢快取中查ID
         * 再根據查詢到的ID去二級快取中查物件 若此時二級快取打開了 那麼不會發SQL
         * 若二級快取沒開啟  那麼此時會再次根據查到的ID去資料庫中查詢
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*
         * 
         */
        try
        {
          //此時關閉了student的二級快取 打開了查詢快取 發出大量SQL
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test10()
    {
        /*
         * 此時打開了二級快取（存物件）
         * 打開了查詢快取（存ID）
         * ！！！！工作順序：如果正常開啟了查詢快取，先去查詢快取中查ID
         * 再根據查詢到的ID去二級快取中查物件 若此時二級快取打開了 那麼不會發SQL
         * 若二級快取沒開啟  那麼此時會再次根據查到的ID去資料庫中查詢
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*
         * 
         */
        try
        {
          //此時打開了student的二級快取 打開了查詢快取 不發SQL
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test11()
    {
        /*
         * 此時打開了二級快取（存物件）
         * 打開了查詢快取（存ID）
         * ！！！！工作順序：如果正常開啟了查詢快取，先去查詢快取中查ID
         * 再根據查詢到的ID去二級快取中查物件 若此時二級快取打開了 那麼不會發SQL
         * 若二級快取沒開啟  那麼此時會再次根據查到的ID去資料庫中查詢
         */
        Session session = null;
        Transaction trans = null;
        try
        {   //一條SQL
            session = HibernateUtil.openSession();
            List<Object[]> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張%").list();//開啟查詢快取  查詢快取也是sessionFactory級別的快取
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
        /*
         * 
         */
        try
        {
          //此時雖然打開了student的二級快取 但是不能使用查詢快取（HQL不一致）導致沒法通過查詢快取查ID去
           //二級快取中查物件
          //所以仍然發出一條SQL 從資料庫中查詢
            session = HibernateUtil.openSession();
            List<Student> ls = session.createQuery("select stu  from Student stu where name like ?")
                .setCacheable(true).setParameter(0, "%張三%").list();
            Iterator<Student> it=ls.iterator();
            while (it.hasNext())
            {
                Student stu = it.next();
                System.out.println(stu.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != session)
                HibernateUtil.closeSession(session);
        }
    }
}


相關推薦

hibernate--一級和二級快取（使用Ehcache）以及查詢快取

有一下幾點需要理清才行： 一級快取是session快取 session關閉就小時 二級快取是sessionFactory級別的快取 一個應用程式只有一個 多個執行緒共享  不要把經常修改的物件放到二級快取中 二級快取中放一些查詢的物件 1 首先是在hibernate,cfg

hibernate 一級和二級快取使用總結

   hibernate的快取分為一級快取和二級快取，一級二級和我們常說的cpu的一級二級是不一樣的。這裡的一級說的是session的快取，是hibernate內建的，不能解除安裝。二級說的是SessionFactory中的外接快取，SessionFactory的內建快取是放對映資料和sql語句的，程式不能

capture JS中的事件冒泡（Bubble）和事件捕獲（capture）以及如何阻止事件的冒泡

JS中的事件冒泡（Bubble）和事件捕獲（capture）以及如何阻止事件的冒泡 對“捕獲”和“冒泡”這兩個概念，通常我們對冒泡瞭解和使用的會更多一些，因為在我們使用的所有瀏覽器中，都支援事件冒泡 ，即事件由子元素向祖先元素傳播的，就像氣泡從水底向水面上浮一樣。而在像firefox,chrome,safa

iOS開發之快取（一）：記憶體快取

點選有驚喜 前面一片文章介紹瞭如何上傳和下載檔案，這篇文章將介紹一下如何在iOS裝置中進行快取。 這篇文章將只介紹一下將內容快取到記憶體中，下一篇文章就介紹一下在iOS磁碟上快取內容。 使用快取的目的是為了使用的應用程式能更快速的響應使用者輸入，是程式高效的執行

Python中的類和元類（metaclass）以及黑魔法（__metaclass__）

一、Python中的類 首先在這裡討論的python類，都是基於新式類進行討論。 在python中，一切皆為物件。 在理解元類之前我們先來重新理解一下python中的類。 class Joker: pass 當Python在執行帶clas

Hibernate之二 一級快取（session）、二級快取（sessionFactory）

一、操作Session快取 （1）flush Session 按照快取中物件的屬性變化來同步更新資料庫 1）預設情況下 Session 在以下時間點重新整理快取： 顯式呼叫 Session 的 flush() 方法 當應用程式呼叫 Transaction

液化天然氣用一級和二級燃氣減壓閥減壓器調壓閥、2500m3（800方）

燃氣調壓閥門液化天然氣用一級和二級燃氣減壓閥減壓器調壓閥、2500m3（800方）液化天然氣用2500m3（800方）液化天然氣用一級調壓閥調壓器減壓閥減壓器2500m3（800方）壓縮天然氣用一級和二級燃氣減壓閥減壓器調壓閥、2500m3（800方）壓縮天然氣用2500m3（800方）壓縮天然氣用一級調壓閥

mybatis基礎系列（四）——關聯查詢、延遲載入、一級快取與二級快取

關本文是Mybatis基礎系列的第四篇文章，點選下面連結可以檢視前面的文章： mybatis基礎系列（三）——動態sql mybatis基礎系列（二）——基礎語法、別名、輸入對映、輸出對映 mybatis基礎系列（一）——mybatis入門 關聯查詢 在進行表設計時，往往需要在具體的業務基礎上分析表與表之間的

hibernate的二級快取（09）

為什麼需要快取 拉高程式的效能 關係型資料庫：資料與資料之間存在關係（聯絡）的資料庫 mysql/Oracle、sqlserver 非關係型資料庫：資料與資料之間是不存在關係的，key-value 1、基於檔案儲存的資料庫：ehcache 快取 2、基於記憶

Mybatis的一級和二級快取

作用域 一級快取：session,當openSession()之後，如果執行相同的sql(相同的語句和引數)，Mybatis不執行sql，而是從快取中返回 二級快取：mapper的一個namespace,同一個namespace中查詢sql可以從快取中獲取，二級快取可以跨sessio

強制快取（200）和協商快取（304）整理

1、瀏覽器快取 瀏覽器第一次開啟一個網頁獲取資源後，根據返回的header資訊來告訴如何快取資源。 瀏覽器第一次請求： 瀏覽器後續請求時： 瀏覽器在請求某一資源時，會先獲取該資源快取的header資訊，判斷是否命中強快取（cache-control和

實習日誌（3）mybaits1級快取和2級快取

從<cache>和<cache-ref>說起 一級快取 一級快取預設是開啟的，是由baseExecutor來 維護，預設級別是session級別 protected PerpetualCache localCache; 至於PerpetualCache只

用MyEclipse自動生成Hibernate對映檔案和實體類（Javabean）

做web專案，使用SSH框架時，資料庫中許多的表都需要在專案中建立一個實體類和對映檔案，如果專案中資料表太多，一個一個在專案中建立，肯定是非常浪費時間的，有時候還會寫錯。其實，用MyEclipse可以直接生成資料庫中所有資料表的對映檔案和實體類，簡單快捷。 資

CentOS7（Linux）清理yum快取 和釋放記憶體方法

清理yum快取 清理yum快取使用yum clean 命令，yum clean 的引數有headers, packages, metadata, dbcache, plugins, expire-cache, rpmdb, all yum clean h

Hibernate和Mybatis對比（優缺點）

專案也做過幾個, 使用Mybatis就做一個專案, 基本上都是使用Hibernate, 也只是知道幾點關於這兩個框架的區別, 今天閒著沒事幹, 從網上找了幾篇文章, 做了一個簡單的整理。網上關於這兩

Hibernate中的即時載入（get）和延時載入（load）

一，即時載入     Student student = session.get(Student.class, 22);     System.out.println(student);       &nb

一級和二級快取使用詳解

【1】一級快取 JPA預設情況下和MyBatis一樣開啟一級快取。JPA是針對與entityManager，Mybatis是針對於namespace。 示例程式碼如下： @Test public void testSecondLevelCache(){ Cust

說說自己對hibernate一級、二級、查詢、快取的理解。

今天面試碰到答不上來。。馬上回家查了下，現在寫下對hibernate快取的理解以加深印象。 1、一級快取 可以簡單的理解為session快取，即同一個session中使用get、load、迭代，會優先重快取中取，如果沒有則查詢資料庫並存入快取，session關閉後快取清空

mybatis 快取（一） 一級快取

所謂快取 指的是將與資料庫的一次會話所查出的資料存入快取中，如果之後需要查詢相同的資料，就不需要繼續向資料庫傳送sql語句，直接將資料從快取中取出 一級快取：也叫本地快取，是mybaits預設開啟的，是sqlsession級別的快取，每一個sqlsessio

Spring Boot 學習之快取和 NoSQL 篇（四）

該系列並非完全原創，官方文件、作者一、前言當系統的訪問量增大時，相應的資料庫的效能就逐漸下降。但是，大多數請求都是在重複的獲取相同的資料，如果使用快取，將結果資料放入其中可以很大程度上減輕資料庫的負擔，提升系統的響應速度。本篇將介紹 Spring Boot 中快取和 NoSQ