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。

 

 

　　

 

 

 

 

转载于:https://www.cnblogs.com/maidouerer/p/10487163.html