ehcache的學習筆記（一）

學習ehcache文檔：

介紹：Ehcache是一個開源的項目，用來提高性能的基於標准化的緩存，無需使用數據庫，簡化了可擴展性。他是最廣泛使用的基於java的緩存，因為他是強壯的，被證實的，功能全面的，並且可以和其他的流行的庫和框架整合。Ehcache從進程內到進程內外以TB級的緩存混合部署。

目前最新的可用版本是：3.7。這個版本增加了堆上的性能。需要使用java8+。在接下來的幾個月里可以看到3.x系列的功能的持續快速的改進。

Ehcache3介紹：

• 改進了使用java泛型的API以及簡化了緩存的交互，
• 完全兼容了javax.cache API，
• 離堆存儲能力，包括離堆緩存
• 由於javax.cache的支持，對spring緩存和hibernate集成是開箱即用的，等等。。。

開始使用Ehcache3

　　引入Ehcache到項目里，要么使用他的最新的API，也可以使用javax.cache API。

　　使用 the core Ehcache v3 API，Ehcache 3有一個流線型的、現代化的類型安全API(和配置)，與Ehcache 2.x相比，它將極大地改善您的編碼體驗。

　　引入jars

    <dependency>
      <groupId>org.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>3.7.0</version>
    </dependency>

 

　　使用Ehcache 3 API:

　　

 CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
          .withCache("preConfigured",
               CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                              ResourcePoolsBuilder.heap(100))
               .build())
          .build(true);

      Cache<Long, String> preConfigured
          = cacheManager.getCache("preConfigured", Long.class, String.class);

      Cache<Long, String> myCache = cacheManager.createCache("myCache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                        ResourcePoolsBuilder.heap(100)).build());

      myCache.put(1L, "da one!");
      String value = myCache.get(1L);

      cacheManager.close();

 

除了上面的，還需要the JSR-107 API，導入jars

    <dependency>
      <groupId>javax.cache</groupId>
      <artifactId>cache-api</artifactId>
      <version>1.1.0</version>
    </dependency>

 　　文檔：

　　配置Ehcache:java配置可以通過提供一個API來很容易的得到。和以前的版本一樣，處理cache最權威的方式是通過一個CacheManage。

CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder() 
    .withCache("preConfigured",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10))) 
    .build(); 
cacheManager.init(); 

Cache<Long, String> preConfigured =
    cacheManager.getCache("preConfigured", Long.class, String.class); 

Cache<Long, String> myCache = cacheManager.createCache("myCache", 
    CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10)));

myCache.put(1L, "da one!"); 
String value = myCache.get(1L); 

cacheManager.removeCache("preConfigured"); 

cacheManager.close(); 

1.CacheManagerBuilder.newCacheManagerBuilder()，org.ehcache.config.builders.CacheManagerBuilder.newCacheManagerBuilder這個靜態方法返回了一個新的org.ehcache.config.builders.CacheManagerBuilder的實例。

2..withCache("preConfigured",CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10))) ，使用這個builder去定義一個叫“preConfigured”的緩存。當在CacheManager實例上，cacheManager.build()被調用時，這個緩存將被創建。第一個string參數是緩存的別名，他被用於從CacheManager來檢索緩存。第二個參數org.ehcache.config.CacheConfiguration被用來配置這個緩存。我們在rg.ehcache.config.builders.CacheConfigurationBuilder上使用newCacheConfigurationBuilder()靜態方法來創建一個默認的配置。

3..build()，最后調用build（）返回了一個完全實例化但是還沒有初始化的CacheManager。

4.cacheManager.init()，使用CacheManager之前，他需要被初始化，可以使用兩種方式的一種：在CacheManager實例上調用CacheManager.init()或者調用CacheManagerBuilder.build(boolean init)方法，boolean參數設為true。

5.cacheManager.getCache("preConfigured", Long.class, String.class);

一個緩存是通過他的別名，key的類型，value的類型來索引的。比如說，要去得到在第二步聲明的緩存，你需要他的別名="preConfigured"，keyType=Long.class，valueType=String.class。為了類型安全，我們要求傳入key和value的類型。如果我們期望的東西有不同的地方，CacheManager會在應用的生命周期中盡早的拋出一個ClassCastException。這樣可以防止the Cache被混亂的類型污染。

6.Cache<Long, String> myCache = cacheManager.createCache("myCache",

CacheManager可以根據需要創建新的Cache實例。和步驟2CacheConfiguration一樣,他也需要傳入一個別名。添加進來的已經被實例化和初始化的Cache通過CacheManager.getCache的API被返回或者存取。

7.myCache.put(1L, "da one!");

最近添加過的Cache可以被存入條目里,這個條目是由鍵值對組成。這個put方法第一個參數是key，第二個參數是value。記得這個key和value的類型必須和被定義在CacheConfiguration里的類型一樣。此外，鍵必須是唯一的，只能和一個值關聯。

8.String value = myCache.get(1L);

通過調用cache.get(key)方法從緩存中檢索值。他只接受一個key，返回相關聯的value。如果沒有相關聯的value，返回null。

9.cacheManager.removeCache("preConfigured");

我們可以刪除一個給定的Cache，CacheManager不僅會刪除對緩存的引用，還會關閉它。這個緩存會釋放所有的本地的臨時資源（比如內存）。這個緩存的引用變得不可用。

10.cacheManager.close();

為了釋放所有的臨時資源（內存，線程），一個CacheManager提供他所管理的緩存實例，調用CacheManager.close()，它會依次關閉所有的緩存實例。

這有3個重要的事情：

 

 

try(CacheManager cacheManager = newCacheManagerBuilder() 
  .withCache("preConfigured", newCacheConfigurationBuilder(Long.class, String.class, heap(10))) 
  .build(true)) { 

  // Same code as before [...]
}

1.CacheManager 實現了Closeable，所以可以自動地通過try-with-resources關閉。CacheManage必須關閉的干凈。.在finally塊中，使用try-with-resources或者其他更常見的方式來關閉

2.builders有不同的名稱，你可以使用靜態導入所有。

3.CacheManage使用build(true)來初始化。

使用XML配置：可以通過創建xml文件配置一個CacheManager

 

<config xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
    xmlns='http://www.ehcache.org/v3'
    xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core.xsd">
  <cache alias="foo"> 
    <key-type>java.lang.String</key-type> 
    <value-type>java.lang.String</value-type> 
    <resources>
      <heap unit="entries">20</heap> 
      <offheap unit="MB">10</offheap> 
    </resources>
  </cache>
  <cache-template name="myDefaults"> 
    <key-type>java.lang.Long</key-type>
    <value-type>java.lang.String</value-type>
    <heap unit="entries">200</heap>
  </cache-template>
  <cache alias="bar" uses-template="myDefaults"> 
    <key-type>java.lang.Number</key-type>
  </cache>
  <cache alias="simpleCache" uses-template="myDefaults" /> 

</config>

1.聲明一個叫foo的緩存

2.foo的key,value為string類型，默認是object

3.<heap unit="entries">20</heap> 在堆上容納2000entries.


4.<offheap unit="MB">10</offheap> 500MB的離堆內存

5.<cache-template>這個元素讓你創建一個抽象的配置，<cache>可以對他擴展

6.bar是一個cache，bar使用叫'myDefaults'的<cache-template>，重寫了他的key類型

7.simpleCache是另一個cache，它使用了myDefaults配置他唯一的CacheConfiguration。

 

為了去解析XML配置，可以使用XmlCOnfiguration類：

URL myUrl = getClass().getResource("/my-config.xml"); 
Configuration xmlConfig = new XmlConfiguration(myUrl); 
CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(xmlConfig); 

1.得到XML文件的本地的URL

2.實例化Configuration類

3.使用靜態的org.ehcache.config.builders.CacheManagerBuilder.newCacheManager(org.ehcache.config.Configuration)，讓你創建你的CacheManage實例，這個實例用於從XMLConfiguration中使用Configuration.

創建一個支持集群的緩存管理器

 要啟用Terracotta集群，首先必須啟動配置了集群存儲的Terracotta服務器。另外，為了創建有集群支持的cachemanage,你必須提供集群服務配置。

CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
    CacheManagerBuilder.newCacheManagerBuilder() 
        .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application")) 
            .autoCreate()); 
PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); 

cacheManager.close();

1.CacheManagerBuilder.newCacheManagerBuilder() 返回org.ehcache.config.builders.CacheManagerBuilde 實例。

2..with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application"))

使用ClusteringServiceConfigurationBuilder的靜態方法.cluster(URL)，是為了連接cacheManage到URL地址上的集群存儲，返回一個集群的服務配置builer實例。在例子中的URL指向了Terracotta服務器上具有集群存儲標識符my-application的集群存儲（假設服務器運行在本地主機和端口9410上）。如果集群存儲還不存在，query-param自動創建將在服務器中創建集群存儲。

3.autoCreate():返回一個初始化的cacheManage，他可以用來創建集群緩存。

4.PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true);

如果集群存儲不存在的話會自動創建它。

5.cacheManager.close():關閉cacheManager。

存儲層

Ehcache3，作為一個以前的版本，提供了一個分層模型，允許在較慢的層（通常更豐富）存儲大量數據。其理念是，存儲更快，資源更少，但是是最熱門數據的首選位置。較少熱（較少使用）的數據被移動到更加豐富但是更慢的層。更熱的數據移動到更快的層

一個經典的例子是使用帶有持久磁盤存儲的3層。

 

PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
    .with(CacheManagerBuilder.persistence(new File(getStoragePath(), "myData"))) 
    .withCache("threeTieredCache",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
            ResourcePoolsBuilder.newResourcePoolsBuilder()
                .heap(10, EntryUnit.ENTRIES) 
                .offheap(1, MemoryUnit.MB) 
                .disk(20, MemoryUnit.MB, true) 
            )
    ).build(true);

Cache<Long, String> threeTieredCache = persistentCacheManager.getCache("threeTieredCache", Long.class, String.class);
threeTieredCache.put(1L, "stillAvailableAfterRestart"); 

persistentCacheManager.close();

1.PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()

    .with(CacheManagerBuilder.persistence(new File(getStoragePath(), "myData")))

如果你想要使用磁盤存儲（比如持久化緩存實例），你需要提供一個位置，以便將數據存儲到CacheManagerBuilder.persistence()靜態方法的磁盤上。

 2.ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES)

給堆區定義一個資源池。他將成為你的更快的但是更緩慢的池。


3..offheap(1, MemoryUnit.MB) 為離堆區定義一個資源池，很快而且大。


4..disk(20, MemoryUnit.MB, true) 為磁盤定義一個持久化的資源池。最后一個參數是true

5.threeTieredCache.put(1L, "stillAvailableAfterRestart"); JVM重啟后所有的緩存值也是可用的（假設通過close（）關閉CacheManager）。

數據新鮮度

數據的新鮮度通過過期時間（Expiry）來控制。下面的說明怎么配置生命周期

CacheConfiguration<Long, String> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.heap(100)) 
    .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(20))) 
    .build();

1.過期是在緩存級別配置的，所以首先定義一個緩存配置

2.然后添加上一個Expiry,這里使用預定義的生存時間，配置需要的Duration。