spring-data-jpa+hibernate 各類緩存的配置演示

時間  2019-12-14
標籤 spring data jpa+hibernate jpa hibernate 各類 緩存 配置 演示 欄目 Spring 简体版
原文   原文鏈接

本文全部測試用代碼在https://github.com/wwlleo0730/restjplat 的分支addDB上

目前在使用spring-data-jpa和hibernate4的時候，對於緩存關係不是很清楚，以及二級緩存和查詢緩存的各類配置等等，因而就有了這篇初級的jpa+hibernate緩存配置使用的文章。


JPA和hibernate的緩存關係，以及系統demo環境說明

JPA全稱是：Java Persistence API
java

引用
JPA itself is just a specification, not a product; it cannot perform persistence or anything else by itself.

JPA僅僅只是一個規範，而不是產品；使用JPA自己是不能作到持久化的。



因此，JPA只是一系列定義好的持久化操做的接口，在系統中使用時，須要真正的實現者，在這裏，咱們使用Hibernate做爲實現者。因此，仍是用spring-data-jpa+hibernate4+spring3.2來作demo例子說明本文。


JPA規範中定義了不少的緩存類型：一級緩存，二級緩存，對象緩存，數據緩存，等等一系列概念，搞的人糊里糊塗，具體見這裏：
http://en.wikibooks.org/wiki/Java_Persistence/Caching

不過緩存也必需要有實現，由於使用的是hibernate，因此基本只討論hibernate提供的緩存實現。

不少其餘的JPA實現者，好比toplink（EclipseLink），也許還有其餘的各類緩存實現，在此就不說了。



先直接給出全部的demo例子

hibernate實現中只有三種緩存類型：

一級緩存，二級緩存和查詢緩存。

在hibernate的實現概念裏，他把什麼集合緩存之類的統一放到二級緩存裏去了。


1. 一級緩存測試：

文件配置：

git

Java代碼   收藏代碼
  1. <bean id="entityManagerFactory"  
  2.     class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
  3.     <property name="dataSource" ref="dataSource" />  
  4.     <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />  
  5.     <property name="packagesToScan" value="com.restjplat.quickweb" />  
  6.     <property name="jpaProperties">  
  7.         <props>  
  8.             <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
  9.             <prop key="hibernate.format_sql">true</prop>  
  10.         </props>  
  11.     </property>  
  12. </bean>  



可見沒有添加任何配置項。

github

Java代碼   收藏代碼
  1. private void firstCacheTest(){    
  2.     EntityManager em = emf.createEntityManager();  
  3.     Dict d1 = em.find(Dict.class, 1); //find id爲1的對象  
  4.     Dict d2 = em.find(Dict.class, 1); //find id爲1的對象  
  5.     logger.info((d1==d2)+""); //true  
  6.   
  7.     EntityManager em1 = emf.createEntityManager();  
  8.     Dict d3 = em1.find(Dict.class, 1); //find id爲1的對象  
  9.     EntityManager em2 = emf.createEntityManager();  
  10.     Dict d4 = em2.find(Dict.class, 1); //find id爲1的對象  
  11.     logger.info((d3==d4)+""); //false  
  12. }  



Java代碼   收藏代碼
  1. 輸出爲：由於sql語句打出來太長，因此用*號代替  
  2. Hibernate: ***********  
  3. 2014-03-17 20:41:44,819  INFO [main] (DictTest.java:76) - true  
  4. Hibernate: ***********  
  5. Hibernate: ***********  
  6. 2014-03-17 20:41:44,869  INFO [main] (DictTest.java:84) - false  



因而可知：同一個session內部，一級緩存生效，同一個id的對象只有一個。不一樣session，一級緩存無效。

2. 二級緩存測試：

文件配置：

1:實體類直接打上 javax.persistence.Cacheable 標記。
web

Java代碼   收藏代碼
  1. @Entity  
  2. @Table(name ="dict")  
  3. @Cacheable  
  4. public class Dict extends IdEntity{}  



2：配置文件修改，在 jpaProperties 下添加，用ehcache來實現二級緩存，另外由於加入了二級緩存，咱們將hibernate的統計打開來看看究竟是不是被緩存了。
spring

Java代碼   收藏代碼
  1. <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>  
  2. <prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>  
  3. <prop key="hibernate.generate_statistics">true</prop>  



注1：若是在配置文件中加入了
<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>，則不須要在實體內配置hibernate的 @cache標記，只要打上JPA的@cacheable標記便可默認開啓該實體的2級緩存。

注2：若是不使用javax.persistence.sharedCache.mode配置，直接在實體內打@cache標記也能夠。

sql

Java代碼   收藏代碼
  1. @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)  
  2. public class Dict extends IdEntity{}  



至於 hibernate的 hibernate.cache.use_second_level_cache這個屬性，文檔裏是這麼寫的：
緩存

引用
Can be used to completely disable the second level cache, which is enabled by default for classes which specify a <cache> mapping.


即打上只要有@cache標記，自動開啓。

因此有兩種方法配置開啓二級緩存：

第一種不使用hibernate的@cache標記，直接用@cacheable標記和緩存映射配置項。

第二種用hibernate的@cache標記使用。


另外javax.persistence.sharedCache.mode的其餘配置以下：

The javax.persistence.sharedCache.mode property can be set to one of the following values:
session

    • ENABLE_SELECTIVE (Default and recommended value): entities are not cached unless explicitly marked as cacheable.
    • DISABLE_SELECTIVE: entities are cached unless explicitly marked as not cacheable.
    • NONE: no entity are cached even if marked as cacheable. This option can make sense to disable second-level cache altogether.
    • ALL: all entities are always cached even if marked as non cacheable.

若是用all的話，連實體上的@cacheable都不用打，直接默認所有開啓二級緩存

測試代碼：

app

Java代碼   收藏代碼
  1. private void secondCachetest(){  
  2.         EntityManager em1 = emf.createEntityManager();  
  3.         Dict d1 = em1.find(Dict.class, 1); //find id爲1的對象  
  4.         logger.info(d1.getName());  
  5.         em1.close();  
  6.           
  7.         EntityManager em2 = emf.createEntityManager();  
  8.         Dict d2 = em2.find(Dict.class, 1); //find id爲1的對象  
  9.         logger.info(d2.getName());  
  10.         em2.close();  
  11.     }  


輸出：
less

Java代碼   收藏代碼
  1. Hibernate: **************  
  2. a  
  3. a  
  4. ===================L2======================  
  5. com.restjplat.quickweb.model.Dict : 1  



可見二級緩存生效了，只輸出了一條sql語句，同時監控中也出現了數據。

另外也能夠看看若是是配置成ALL，而且把@cacheable刪掉,輸出以下：

Java代碼   收藏代碼
  1. Hibernate: ************  
  2. a  
  3. a  
  4. ===================L2======================  
  5. com.restjplat.quickweb.model.Children : 0  
  6. com.restjplat.quickweb.model.Dict : 1  
  7. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  8. org.hibernate.cache.internal.StandardQueryCache : 0  
  9. com.restjplat.quickweb.model.Parent : 0  
  10. =================query cache=================  



而且能夠看見，全部的實體類都加入二級緩存中去了


3. 查詢緩存測試：

一，二級緩存都是根據對象id來查找，若是須要加載一個List的時候，就須要用到查詢緩存。

在Spring-data-jpa實現中，也可使用查詢緩存。

文件配置：
在 jpaProperties 下添加，這裏必須明確標出增長查詢緩存。

Java代碼   收藏代碼
  1. <prop key="hibernate.cache.use_query_cache">true</prop>  



而後須要在方法內打上@QueryHint來實現查詢緩存，咱們寫幾個方法來測試以下：

Java代碼   收藏代碼
  1. public interface DictDao extends JpaRepository<Dict, Integer>,JpaSpecificationExecutor<Dict>{  
  2.   
  3.     // spring-data-jpa默認繼承實現的一些方法，實現類爲  
  4.     // SimpleJpaRepository。  
  5.     // 該類中的方法不能經過@QueryHint來實現查詢緩存。  
  6.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  7.     List<Dict> findAll();  
  8.       
  9.     @Query("from Dict")  
  10.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  11.     List<Dict> findAllCached();  
  12.       
  13.     @Query("select t from Dict t where t.name = ?1")  
  14.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  15.     Dict findDictByName(String name);  
  16. }  



測試方法：

Java代碼   收藏代碼
  1. private void QueryCacheTest(){  
  2.         //無效的spring-data-jpa實現的接口方法  
  3.         //輸出兩條sql語句  
  4.         dao.findAll();  
  5.         dao.findAll();  
  6.         System.out.println("================test 1 finish======================");  
  7.         //本身實現的dao方法能夠被查詢緩存  
  8.         //輸出一條sql語句  
  9.         dao.findAllCached();  
  10.         dao.findAllCached();  
  11.         System.out.println("================test 2 finish======================");  
  12.         //本身實現的dao方法能夠被查詢緩存  
  13.         //輸出一條sql語句  
  14.         dao.findDictByName("a");  
  15.         dao.findDictByName("a");  
  16.         System.out.println("================test 3 finish======================");  
  17.     }  



輸出結果：

Java代碼   收藏代碼
  1. Hibernate: **************  
  2. Hibernate: **************  
  3. ================test 1 finish======================  
  4. Hibernate: ***********  
  5. ================test 2 finish======================  
  6. Hibernate: ***********  
  7. ================test 3 finish======================  
  8. ===================L2======================  
  9. com.restjplat.quickweb.model.Dict : 5  
  10. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  11. org.hibernate.cache.internal.StandardQueryCache : 2  
  12. =================query cache=================  
  13. select t from Dict t where t.name = ?1  
  14. select generatedAlias0 from Dict as generatedAlias0  
  15. from Dict  



很明顯，查詢緩存生效。可是爲何第一種方法查詢緩存沒法生效，緣由不明，只能後面看看源代碼了。

4.集合緩存測試：

根據hibernate文檔的寫法，這個應該是算在2級緩存裏面。

測試類：

Java代碼   收藏代碼
  1. @Entity  
  2. @Table(name ="parent")  
  3. @Cacheable  
  4. public class Parent extends IdEntity {  
  5.       
  6.     private static final long serialVersionUID = 1L;  
  7.     private String name;  
  8.     private List<Children> clist;  
  9.       
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.       
  17.     @OneToMany(fetch = FetchType.EAGER,mappedBy = "parent")  
  18.         @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)  
  19.     public List<Children> getClist() {  
  20.         return clist;  
  21.     }  
  22.     public void setClist(List<Children> clist) {  
  23.         this.clist = clist;  
  24.     }  
  25. }  
  26.   
  27. @Entity  
  28. @Table(name ="children")  
  29. @Cacheable  
  30. public class Children extends IdEntity{  
  31.   
  32.     private static final long serialVersionUID = 1L;  
  33.     private String name;  
  34.     private Parent parent;  
  35.       
  36.     @ManyToOne(fetch = FetchType.LAZY)  
  37.     @JoinColumn(name = "parent_id")  
  38.     public Parent getParent() {  
  39.         return parent;  
  40.     }  
  41.   
  42.     public void setParent(Parent parent) {  
  43.         this.parent = parent;  
  44.     }  
  45.   
  46.     public String getName() {  
  47.         return name;  
  48.     }  
  49.   
  50.     public void setName(String name) {  
  51.         this.name = name;  
  52.     }     
  53. }  



測試方法：

Java代碼   收藏代碼
  1. private void cellectionCacheTest(){  
  2.         EntityManager em1 = emf.createEntityManager();  
  3.         Parent p1 = em1.find(Parent.class, 1);  
  4.         List<Children> c1 = p1.getClist();  
  5.         em1.close();  
  6.         System.out.println(p1.getName()+" ");  
  7.         for (Children children : c1) {  
  8.             System.out.print(children.getName()+",");  
  9.         }  
  10.         System.out.println();  
  11.         EntityManager em2 = emf.createEntityManager();  
  12.         Parent p2 = em2.find(Parent.class, 1);  
  13.         List<Children> c2 = p2.getClist();  
  14.         em2.close();  
  15.         System.out.println(p2.getName()+" ");  
  16.         for (Children children : c2) {  
  17.             System.out.print(children.getName()+",");  
  18.         }  
  19.         System.out.println();  
  20.     }  



輸出：

Java代碼   收藏代碼
  1. Hibernate: ********************  
  2. Michael   
  3. kate,Jam,Jason,Brain,  
  4. Michael   
  5. kate,Jam,Jason,Brain,  
  6. ===================L2======================  
  7. com.restjplat.quickweb.model.Children : 4  
  8. com.restjplat.quickweb.model.Dict : 0  
  9. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  10. com.restjplat.quickweb.model.Parent.clist : 1  
  11. org.hibernate.cache.internal.StandardQueryCache : 0  
  12. com.restjplat.quickweb.model.Parent : 1  
  13. =================query cache=================  



在統計數據裏可見二級緩存的對象數量。

本文咱們不討論關於緩存的更新策略，髒數據等等的東西，只是講解配置方式。


接下來是源代碼篇

理清楚各類配置之後，咱們來看一下hibernate和spring-data-jpa的一些緩存實現源代碼。

上面有個遺留問題，爲何spring-data-jpa默認實現的findAll（）方法沒法保存到查詢緩存？只能啃源代碼了。

打斷點跟蹤吧

入口方法是spring-data-jpa裏的 SimpleJpaRepository類

Java代碼   收藏代碼
  1. public List<T> findAll() {  
  2.         return getQuery(null, (Sort) null).getResultList();  
  3.     }  
  4.   
  5. 而後到 QueryImpl<X>類的  
  6. private List<X> list() {  
  7.         if (getEntityGraphQueryHint() != null) {  
  8.             SessionImplementor sessionImpl = (SessionImplementor) getEntityManager().getSession();  
  9.             HQLQueryPlan entityGraphQueryPlan = new HQLQueryPlan( getHibernateQuery().getQueryString(), false,  
  10.                     sessionImpl.getEnabledFilters(), sessionImpl.getFactory(), getEntityGraphQueryHint() );  
  11.             // Safe to assume QueryImpl at this point.  
  12.             unwrap( org.hibernate.internal.QueryImpl.class ).setQueryPlan( entityGraphQueryPlan );  
  13.         }  
  14.         return query.list();  
  15.     }  
  16.   
  17. 進入query.list();  
  18.   
  19. query類的代碼解析google一下不少，因而直接到最後：  
  20.   
  21. 進入QueryLoader的list方法。  
  22.   
  23. protected List list(  
  24.             final SessionImplementor session,  
  25.             final QueryParameters queryParameters,  
  26.             final Set<Serializable> querySpaces,  
  27.             final Type[] resultTypes) throws HibernateException {  
  28.   
  29.         final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&  
  30.             queryParameters.isCacheable();  
  31.   
  32.         if ( cacheable ) {  
  33.             return listUsingQueryCache( session, queryParameters, querySpaces, resultTypes );  
  34.         }  
  35.         else {  
  36.             return listIgnoreQueryCache( session, queryParameters );  
  37.         }  
  38.     }  



果真有個cacheable，值爲false，說明的確是沒有從緩存裏取數據。

用自定義的jpa查詢方法測試後發現，這個值爲true。

因而接着看cacheable的取值過程：

Java代碼   收藏代碼
  1. final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&  
  2.             queryParameters.isCacheable();  



factory.getSettings().isQueryCacheEnabled() 這個必定是true，由於是在配置文件中打開的。那隻能是queryParameters.isCacheable() 這個的問題了。

Java代碼   收藏代碼
  1. 在query.list()的方法內部：  
  2.   
  3. public List list() throws HibernateException {  
  4.         verifyParameters();  
  5.         Map namedParams = getNamedParams();  
  6.         before();  
  7.         try {  
  8.             return getSession().list(  
  9.                     expandParameterLists(namedParams),  
  10.                     getQueryParameters(namedParams)  
  11.                 );  
  12.         }  
  13.         finally {  
  14.             after();  
  15.         }  
  16.     }  
  17.   
  18. getQueryParameters(namedParams)這個方法實際獲取的是query對象的cacheable屬性的值，也就是說，query對象新建的時候cacheable的值決定了這個query方法能不能被查詢緩存。  



接下來query的創建過程：

Java代碼   收藏代碼
  1. 在 SimpleJpaRepository 類中 return applyLockMode(em.createQuery(query));  
  2.   
  3. 直接由emcreate，再跟蹤到 AbstractEntityManagerImpl中  
  4.   
  5. @Override  
  6.     public <T> QueryImpl<T> createQuery(  
  7.             String jpaqlString,  
  8.             Class<T> resultClass,  
  9.             Selection selection,  
  10.             QueryOptions queryOptions) {  
  11.         try {  
  12.             org.hibernate.Query hqlQuery = internalGetSession().createQuery( jpaqlString );  
  13.   
  14.             ....  
  15.             return new QueryImpl<T>( hqlQuery, this, queryOptions.getNamedParameterExplicitTypes() );  
  16.         }  
  17.         catch ( RuntimeException e ) {  
  18.             throw convert( e );  
  19.         }  
  20.     }  
  21. 即經過session.createQuery(jpaqlString ) 建立初始化對象。  
  22.   
  23. 在query類定義中  
  24. public abstract class AbstractQueryImpl implements Query {  
  25.   
  26.         private boolean cacheable;  
  27. }  
  28. cacheable不是對象類型，而是基本類型，因此不賦值的狀況下默認爲「false」。  



也就是說spring-data-jpa接口提供的簡單快速的各類接口實現全是不能使用查詢緩存的，徹底不知道爲何這麼設計。

接下來看看咱們本身實現的查詢方法實現：

直接找到query方法的setCacheable（）方法打斷點，由於確定改變這個值纔能有查詢緩存。


Java代碼   收藏代碼
  1. 因而跟蹤到 SimpleJpaQuery類中  
  2. protected Query createQuery(Object[] values) {  
  3.         return applyLockMode(applyHints(doCreateQuery(values), method), method);  
  4. }  

在返回query的過程當中經過applyHints（）方法讀取了方法上的QueryHint註解從而設置了查詢緩存。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程