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。