Ehcache3之用户管理和存储方式

清疚 2022-09-22 04:59 100阅读 0赞

# 用户管理缓存 #

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

public class UserManaged {
 	
 	public static void main(String[] args) {
 		UserManagedCache<Long, String> userManagedCache =
 			 UserManagedCacheBuilder.newUserManagedCacheBuilder(Long.class, String.class)
 			 .build(false); 
 			userManagedCache.init(); 
 			userManagedCache.put(1L, "hello UserManagedCache!"); 
 			System.out.println(userManagedCache.get(1L));
 			userManagedCache.close(); 
 	}
 
 }

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

### 限制 ###

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

###  ###

### API扩展 ###

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

查看UserManagedCache源码我们可以看到

package org.ehcache;
 
 /**
 * Represents a {@link Cache} that is not managed by a {@link org.ehcache.CacheManager CacheManager}.
 * 
 * These caches must be {@link #close() closed} in order to release all their resources.
 * 
 *
 * @param <K> the key type for the cache
 * @param <V> the value type for the cache
 */
 public interface UserManagedCache<K, V> extends Cache<K, V> {
 
 /**
 * Transitions this {@code UserManagedCache} to {@link org.ehcache.Status#AVAILABLE AVAILABLE}.
 * 
 * If an error occurs before the {@code UserManagedCache} is {@code AVAILABLE}, it will revert to
 * {@link org.ehcache.Status#UNINITIALIZED UNINITIALIZED} and attempt to properly release all resources.
 * 
 *
 * @throws IllegalStateException if the {@code UserManagedCache} is not {@code UNINITIALIZED}
 * @throws StateTransitionException if the {@code UserManagedCache} could not be made {@code AVAILABLE}
 */
 void init() throws StateTransitionException;
 
 /**
 * Transitions this {@code UserManagedCache} to {@link Status#UNINITIALIZED UNINITIALIZED}.
 * 
 * This will release all resources held by this cache.
 * 
 * 
 * Failure to release a resource will not prevent other resources from being released.
 * 
 *
 * @throws StateTransitionException if the {@code UserManagedCache} could not reach {@code UNINITIALIZED} cleanly
 * @throws IllegalStateException if the {@code UserManagedCache} is not {@code AVAILABLE}
 */
 void close() throws StateTransitionException;
 
 /**
 * Returns the current {@link org.ehcache.Status Status} of this {@code UserManagedCache}.
 *
 * @return the current {@code Status}
 */
 Status getStatus();
 
 }

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

package org.ehcache;
 
 /**
 * A {@link UserManagedCache} that holds data that can outlive the JVM.
 *
 * @param <K> the key type for the cache
 * @param <V> the value type for the cache
 */
 public interface PersistentUserManagedCache<K, V> extends UserManagedCache<K, V> {
 
 /**
 * Destroys all persistent data structures for this {@code PersistentUserManagedCache}.
 *
 * @throws java.lang.IllegalStateException if state {@link org.ehcache.Status#MAINTENANCE MAINTENANCE} couldn't be reached
 * @throws CachePersistenceException if the persistent data cannot be destroyed
 */
 void destroy() throws CachePersistenceException;
 }

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

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

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

# 存储层 #

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、磁盘存储。

堆外：

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

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

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

#### 磁盘的持久性 ####

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

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

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

#### Byte-sized堆 ####

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

public static void heap() {
 		CacheConfiguration<Long, String> usesConfiguredInCacheConfig = CacheConfigurationBuilder
 				.newCacheConfigurationBuilder(
 						Long.class,
 						String.class,
 						ResourcePoolsBuilder.newResourcePoolsBuilder()
 								.heap(10, MemoryUnit.KB)
 								.offheap(10, MemoryUnit.MB))
 				.withSizeOfMaxObjectGraph(1000)
 				.withSizeOfMaxObjectSize(1000, MemoryUnit.B).build();
 
 		CacheConfiguration<Long, String> usesDefaultSizeOfEngineConfig = CacheConfigurationBuilder
 				.newCacheConfigurationBuilder(
 						Long.class,
 						String.class,
 						ResourcePoolsBuilder.newResourcePoolsBuilder()
 								.heap(10, MemoryUnit.KB) //你也可以大小字节的堆层。 这将限制使用的堆的层 存储键值对。 注意,有一个成本大小的对象。
 								.offheap(10, MemoryUnit.MB)).build();
 
 		CacheManager cacheManager = CacheManagerBuilder
 				.newCacheManagerBuilder()
 				.withDefaultSizeOfMaxObjectSize(500, MemoryUnit.B) //分级机制可以配置在两个轴:第一个指定的最大数量 的对象遍历走对象图的时候,
 				//第二个定义的最大大小 单一对象。 如果规模以上的这两个限制,变化的操作 缓存将被忽略。
 				.withDefaultSizeOfMaxObjectGraph(2000) //可以提供一个默认的配置缓存管理器级别使用的缓存,除非定义 明确
 				.withCache("usesConfiguredInCache", usesConfiguredInCacheConfig)
 				.withCache("usesDefaultSizeOfEngine",
 						usesDefaultSizeOfEngineConfig).build(true);
 
 		Cache<Long, String> usesConfiguredInCache = cacheManager.getCache(
 				"usesConfiguredInCache", Long.class, String.class);
 
 		usesConfiguredInCache.put(1L, "one");
 		System.out.println(usesConfiguredInCache.get(1L));
 
 		Cache<Long, String> usesDefaultSizeOfEngine = cacheManager.getCache(
 				"usesDefaultSizeOfEngine", Long.class, String.class);
 
 		usesDefaultSizeOfEngine.put(1L, "one");
 		System.out.println(usesDefaultSizeOfEngine.get(1L));
 
 		cacheManager.close();
 	}