ehcache3.2使用

Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大，最初知道它，是从hibernate的缓存开始的。Ehcache 3.2为现在官方最新版；

这个新的主要版本的Ehcache提供以下

• 修改缓存API,利用Java泛型和简化了交互,
• 全面兼容javax。 缓存API(jsr - 107),
• Offheap存储功能,包括Offheap只缓存,
• Ehcache 2.倍提高性能,
• 开箱即用的春天由于javax缓存集成。 缓存的支持,

缓存管理

与之前版本相比，3.0之后主要是通过 CacheManager  我们先从基础实例来讲解一下

[java]  view plain  copy

 print ?

1. import org.ehcache.Cache;  
2. import org.ehcache.CacheManager;  
3. import org.ehcache.config.builders.CacheConfigurationBuilder;  
4. import org.ehcache.config.builders.CacheManagerBuilder;  
5. import org.ehcache.config.builders.ResourcePoolsBuilder;  
6.   
7. /** 
8.  *  
9.  * @Filename: Test.java 
10.  * @Description: 
11.  * @Version: 1.0 
12.  * @Author: lyg 
13.  * @Email: 964793210@qq.com <li>Date: 2016年6月28日</li> 
14.  * @History:<br> 
15.  *  
16.  */  
17. public class Test {  
18.     public static void main(String[] args) {  
19.         CacheManager cacheManager = CacheManagerBuilder  
20.                 .newCacheManagerBuilder()  
21.                 .withCache(  
22.                         "preConfigured",  
23.                         CacheConfigurationBuilder.newCacheConfigurationBuilder(  
24.                                 Long.class, String.class,  
25.                                 ResourcePoolsBuilder.heap(100)).build())  
26.                 .build(true);  
27.   
28.         Cache<Long, String> preConfigured = cacheManager.getCache(  
29.                 "preConfigured", Long.class, String.class);  
30.   
31.         Cache<Long, String> myCache = cacheManager.createCache(  
32.                 "myCache",  
33.                 CacheConfigurationBuilder.newCacheConfigurationBuilder(  
34.                         Long.class, String.class,  
35.                         ResourcePoolsBuilder.heap(100)).build());  
36.           
37.         preConfigured.put(2L, "hello Ehcache");  
38.         String value1=preConfigured.get(2L);  
39.         System.out.println(value1);  
40.         myCache.put(1L, "da one!");  
41.         String value = myCache.get(1L);  
42.         System.out.println(value);  
43.         cacheManager.close();  
44.   
45.     }  
46. }  

1.静态方法 org.ehcache.config.builders.CacheManagerBuilder.newCacheManagerBuilder 返回一个新的 org.ehcache.config.builders.CacheManagerBuilder

2.当我们使用builder来注册一个预先配置好的Cache,当我们调用 .build() 时，实际上是一个已经创建好的CacheManager。第一个参数string是用于给Cache取一个别名，第二个参数 org.ehcache.config.CacheConfiguration 配置 Cache 。 我们使用静态 .newCacheConfigurationBuilder() 方法 org.ehcache.config.builders.CacheConfigurationBuilder 创建一个默认的配置;

3. 最后,调用 .build() 返回一个完全实例化,但未初始化的 CacheManager 供我们使用

4.在我们开始使用CacheManager是，我们需要通过init()builder来初始化它，可以通过布尔值来觉得是否build(boolean);

5.现在开始声明一个Cache,并将他的句柄声明为preConfigured，通过cacheManager的get方法，输入别名得到我们预先声明的Cache;

6.我们可以根据需要创建一个新的Cache,他跟步骤2一样，传入一个别名myCache并进行初始化;

7.接着装载我们的Cache值，并成功的打印出我们的hello Ehcache;

用户管理缓存

用户管理缓存是一个新的概念引入Ehcache 3。 它提供了创建缓存的能力不是由一个管理CacheManager。 因此的名字用户管理缓存。

[java]  view plain  copy

 print ?

1. public class UserManaged {  
2.       
3.     public static void main(String[] args) {  
4.         UserManagedCache<Long, String> userManagedCache =  
5.                 UserManagedCacheBuilder.newUserManagedCacheBuilder(Long.class, String.class)  
6.                     .build(false);   
7.             userManagedCache.init();   
8.             userManagedCache.put(1L, "hello UserManagedCache!");   
9.             System.out.println(userManagedCache.get(1L));  
10.             userManagedCache.close();   
11.     }  
12.   
13. }  

这个功能的目的是满足缓存使用情况的复杂性增加缓存管理器没有附加值。 观点是:本地缓存方法,线程本地缓存缓存的生命周期或其他任何地方比应用程序生命周期较短。

限制

因为不再是一个缓存管理器提供的服务,用户管理缓存的主要限制是用户手工配置所需的所有服务。 当然,如果你发现自己需要大量的服务,也许缓存管理器是一个更好的选择!

API扩展

而一个UserManagedCache扩展Cache,它提供了额外的方法:

查看UserManagedCache源码我们可以看到

[java]  view plain  copy

 print ?

1. package org.ehcache;  
2.   
3. /** 
4.  * Represents a {@link Cache} that is not managed by a {@link org.ehcache.CacheManager CacheManager}. 
5.  * <P> 
6.  *   These caches must be {@link #close() closed} in order to release all their resources. 
7.  * </P> 
8.  * 
9.  * @param <K> the key type for the cache 
10.  * @param <V> the value type for the cache 
11.  */  
12. public interface UserManagedCache<K, V> extends Cache<K, V> {  
13.   
14.   /** 
15.    * Transitions this {@code UserManagedCache} to {@link org.ehcache.Status#AVAILABLE AVAILABLE}. 
16.    * <P> 
17.    * If an error occurs before the {@code UserManagedCache} is {@code AVAILABLE}, it will revert to 
18.    * {@link org.ehcache.Status#UNINITIALIZED UNINITIALIZED} and attempt to properly release all resources. 
19.    * </P> 
20.    * 
21.    * @throws IllegalStateException if the {@code UserManagedCache} is not {@code UNINITIALIZED} 
22.    * @throws StateTransitionException if the {@code UserManagedCache} could not be made {@code AVAILABLE} 
23.    */  
24.   void init() throws StateTransitionException;  
25.   
26.   /** 
27.    * Transitions this {@code UserManagedCache} to {@link Status#UNINITIALIZED UNINITIALIZED}. 
28.    * <P> 
29.    *   This will release all resources held by this cache. 
30.    * </P> 
31.    * <P> 
32.    *   Failure to release a resource will not prevent other resources from being released. 
33.    * </P> 
34.    * 
35.    * @throws StateTransitionException if the {@code UserManagedCache} could not reach {@code UNINITIALIZED} cleanly 
36.    * @throws IllegalStateException if the {@code UserManagedCache} is not {@code AVAILABLE} 
37.    */  
38.   void close() throws StateTransitionException;  
39.   
40.   /** 
41.    * Returns the current {@link org.ehcache.Status Status} of this {@code UserManagedCache}. 
42.    * 
43.    * @return the current {@code Status} 
44.    */  
45.   Status getStatus();  
46.   
47. }  

我们可以看到,这些方法需要明确的去处理缓存的生命周期；

[java]  view plain  copy

 print ?

1. package org.ehcache;  
2.   
3. /** 
4.  * A {@link UserManagedCache} that holds data that can outlive the JVM. 
5.  * 
6.  * @param <K> the key type for the cache 
7.  * @param <V> the value type for the cache 
8.  */  
9. public interface PersistentUserManagedCache<K, V> extends UserManagedCache<K, V> {  
10.   
11.   /** 
12.    * Destroys all persistent data structures for this {@code PersistentUserManagedCache}. 
13.    * 
14.    * @throws java.lang.IllegalStateException if state {@link org.ehcache.Status#MAINTENANCE MAINTENANCE} couldn't be reached 
15.    * @throws CachePersistenceException if the persistent data cannot be destroyed 
16.    */  
17.   void destroy() throws CachePersistenceException;  
18. }  

同时使用CacheManager是不会影响 UserManagedCache缓存的

[java]  view plain  copy

 print ?

1. public static void persistent() {  
2.         //创建持久性服务使用缓存来存储在磁盘上的数据  
3.         LocalPersistenceService persistenceService = new DefaultLocalPersistenceService(  
4.                 new DefaultPersistenceConfiguration(new File("C:/Ehcache", "myUserData")));  
5.   
6.         PersistentUserManagedCache<Long, String> cache = UserManagedCacheBuilder  
7.                 .newUserManagedCacheBuilder(Long.class, String.class)  
8.                 .with(new UserManagedPersistenceContext<Long, String>(  
9.                         "cache-name", persistenceService)) //通过持久性服务建造一个id缓存——  
10.                         //这将产生一个更具体的类型:PersistentUserManagedCache  
11.                 .withResourcePools(  
12.                         ResourcePoolsBuilder.newResourcePoolsBuilder()  
13.                                 .heap(10L, EntryUnit.ENTRIES)  
14.                                 .disk(10L, MemoryUnit.MB, true)).build(true); //声明这里如果数据应该被缓存  
15.   
16.         // Work with the cache  
17.         cache.put(42L, "The Answer!");  
18.         System.out.println(cache.get(42L));  
19.         //关闭缓存时不会删除它保存在磁盘上的数据标记为持久性。  
20.         cache.close();  
21.         try {  
22.             //cache.destroy(); //显示的去销毁缓存数据和记录  
23.         } catch (Exception e) {  
24.             e.printStackTrace();  
25.         }  
26.     }  

如果我们不去显示的去销毁缓存数据的话，会在我们的磁盘里产生一些数据；

存储层

Ehcache 3,在以前的版本中,提供了一种分层模型,允许存储越来越多的数据在低速层 (通常更丰富)。

这个想法就是资源与更快的存储更罕见,但在“热门”数据是首选。 因此将不常用的数据层搬到更丰富但速度较慢。 温度数据断裂 层越快。

存储方式：

1、堆内存储：速度快，但是容量有限。

2、堆外（OffHeapStore）存储：被称为BigMemory，只在企业版本的Ehcache中提供，原理是利用nio的DirectByteBuffers实现，比存储到磁盘上快，而且完全不受GC的影响，可以保证响应时间的稳定性；但是direct buffer的在分配上的开销要比heap buffer大，而且要求必须以字节数组方式存储，因此对象必须在存储过程中进行序列化，读取则进行反序列化操作，它的速度大约比堆内存储慢一个数量级。

（注：direct buffer不受GC影响，但是direct buffer归属的的Java对象是在堆上且能够被GC回收的，一旦它被回收，JVM将释放direct buffer的堆外空间。）

3、磁盘存储。

堆外：

[java]  view plain  copy

 print ?

1. public static void offHeap(){  
2.         CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().withCache("tieredCache",  
3.                 CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,  
4.                     ResourcePoolsBuilder.newResourcePoolsBuilder()  
5.                         .heap(10, EntryUnit.ENTRIES)  
6.                         .offheap(10, MemoryUnit.MB))  //如果你希望使用堆外,您需要定义一个资源池,让你想分配的内存大小。  
7.                     )  
8.                 .build(true);  
9.   
10.             cacheManager.close();  
11.     }  

上面的例子分配少量的堆外。 记住,存储的数据堆必须序列化和反序列化,因此比堆慢。 因此你应该忙堆大量数据,堆也会严重影响垃圾收集。

不要忘记定义在java选项-XX:MaxDirectMemorySize

磁盘的持久性

[java]  view plain  copy

 print ?

1. public static void lasting(){  
2.         PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()  
3.                 .with(CacheManagerBuilder.persistence("url"+ File.separator + "myData"))  //传入磁盘持久化的地址  
4.                 .withCache("persistent-cache", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,  
5.                     ResourcePoolsBuilder.newResourcePoolsBuilder()  
6.                         .heap(10, EntryUnit.ENTRIES)  
7.                         .disk(10, MemoryUnit.MB, true)) //定义一个资源的磁盘池   
8.                     )  
9.                 .build(true);  
10.   
11.             persistentCacheManager.close();  
12.     }  

上面的例子分配少量的磁盘存储。 记住,数据存储在磁盘上必须序列化/反序列化和/从磁盘读-写的 因此比堆和offheap慢。 你应该为大量数据支持磁盘。

使用磁盘存储的另一个原因是跨应用程序重启持久性。 注意,Ehcache 3只提供持久性的干净的关闭。

Byte-sized堆

字节大小的运行时性能的影响取决于大小和图的复杂性数据缓存。

[java]  view plain  copy

 print ?

1. public static void heap() {  
2.         CacheConfiguration<Long, String> usesConfiguredInCacheConfig = CacheConfigurationBuilder  
3.                 .newCacheConfigurationBuilder(  
4.                         Long.class,  
5.                         String.class,  
6.                         ResourcePoolsBuilder.newResourcePoolsBuilder()  
7.                                 .heap(10, MemoryUnit.KB)  
8.                                 .offheap(10, MemoryUnit.MB))  
9.                 .withSizeOfMaxObjectGraph(1000)  
10.                 .withSizeOfMaxObjectSize(1000, MemoryUnit.B).build();  
11.   
12.         CacheConfiguration<Long, String> usesDefaultSizeOfEngineConfig = CacheConfigurationBuilder  
13.                 .newCacheConfigurationBuilder(  
14.                         Long.class,  
15.                         String.class,  
16.                         ResourcePoolsBuilder.newResourcePoolsBuilder()  
17.                                 .heap(10, MemoryUnit.KB) //你也可以大小字节的堆层。 这将限制使用的堆的层 存储键值对。 注意,有一个成本大小的对象。  
18.                                 .offheap(10, MemoryUnit.MB)).build();  
19.   
20.         CacheManager cacheManager = CacheManagerBuilder  
21.                 .newCacheManagerBuilder()  
22.                 .withDefaultSizeOfMaxObjectSize(500, MemoryUnit.B) //分级机制可以配置在两个轴:第一个指定的最大数量 的对象遍历走对象图的时候,  
23.                 //第二个定义的最大大小 单一对象。 如果规模以上的这两个限制,变化的操作 缓存将被忽略。  
24.                 .withDefaultSizeOfMaxObjectGraph(2000) //可以提供一个默认的配置缓存管理器级别使用的缓存,除非定义 明确  
25.                 .withCache("usesConfiguredInCache", usesConfiguredInCacheConfig)  
26.                 .withCache("usesDefaultSizeOfEngine",  
27.                         usesDefaultSizeOfEngineConfig).build(true);  
28.   
29.         Cache<Long, String> usesConfiguredInCache = cacheManager.getCache(  
30.                 "usesConfiguredInCache", Long.class, String.class);  
31.   
32.         usesConfiguredInCache.put(1L, "one");  
33.         System.out.println(usesConfiguredInCache.get(1L));  
34.   
35.         Cache<Long, String> usesDefaultSizeOfEngine = cacheManager.getCache(  
36.                 "usesDefaultSizeOfEngine", Long.class, String.class);  
37.   
38.         usesDefaultSizeOfEngine.put(1L, "one");  
39.         System.out.println(usesDefaultSizeOfEngine.get(1L));  
40.   
41.         cacheManager.close();  
42.     }