[英]EHcache simple example with time-to-live
我需要一個簡單的緩存來在內存中存儲具有特定生存時間的元組。 我在 EHcache 網站上找不到這樣做的方法,該網站主要包含復雜的使用場景。 任何人都可以幫助我嗎?
PS我不使用Spring。
CacheManager cacheManager = initCacheManager();
CacheConfiguration cacheConfiguration = new CacheConfiguration().name("myCache")
.maxEntriesLocalHeap(100)
.timeToLiveSeconds(20);
cacheManager.addCache(new Cache(cacheConfiguration));
<cache name="myCache"
maxEntriesLocalHeap="100"
timeToLiveSeconds="20"/>
Element
Ehcache 2.x 允許您覆蓋每個Element
到期設置:
Element element = new Element("key", "value");
element.setTimeToLive(10);
cache.put(element);
CacheManager cacheManager = initCacheManager();
CacheConfigurationBuilder<Long, String> configuration =
CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder
.heap(100))
.withExpiry(Expirations.timeToLiveExpiration(new Duration(20, TimeUnit.SECONDS)));
cacheManager.createCache("myCache", configuration);
在 Ehcache 3 中,構建器是不可變的,可以安全地共享以從類似的配置創建多個緩存。 如果您使用靜態導入,代碼會更加緊湊,我在這里沒有這樣做是為了簡化在 IDE 中粘貼此代碼段的過程。
<cache alias="myCache">
<expiry>
<ttl unit="seconds">20</ttl>
</expiry>
<heap>100</heap>
</cache>
Expiry
覆蓋在 Ehcache 3.x 中, Expiry
是一個用戶可以實現的接口:
public interface Expiry<K, V> {
Duration getExpiryForCreation(K key, V value);
Duration getExpiryForAccess(K key, ValueSupplier<? extends V> value);
Duration getExpiryForUpdate(K key, ValueSupplier<? extends V> oldValue, V newValue);
}
生存時間匹配getExpiryForCreation
調用,它將接收映射的鍵和值,允許根據映射本身實現不同的到期時間。
此解決方案在 Ehcache 3.8.1 上測試正常,但代碼肯定對任何 Ehcache 3.x 都有效
首先創建一個類來保持一個泛型,實際上任何你可以傳遞給緩存的對象:
import java.io.Serializable;
import java.time.Duration;
public class EhcacheValue<T> implements Serializable {
private static final long serialVersionUID = 1L;
private T object;
private long timeToLive;
public EhcacheValue(T theObject, Duration theDuration) {
object = theObject;
timeToLive = theDuration.getSeconds();
}
public Duration getTimeToLiveDuration() {
return Duration.ofSeconds(timeToLive);
}
public T getObject() {
return object;
}
public void setObject(T theObject) {
object = theObject;
}
public long getTimeToLive() {
return timeToLive;
}
public void setTimeToLive(long theTimeToLive) {
timeToLive = theTimeToLive;
}
}
然后創建一個實現Ehcache 3.x接口ExpiryPolicy的自定義 Expiry 類:
import java.time.Duration;
import java.util.function.Supplier;
import org.ehcache.expiry.ExpiryPolicy;
public class CustomExpiryPolicy<K, V extends EhcacheValue<?>> implements ExpiryPolicy<K, V> {
public CustomExpiryPolicy() {
}
@Override
public Duration getExpiryForCreation(K theKey, V theValue) {
return theValue.getTimeToLiveDuration();
}
@Override
public Duration getExpiryForAccess(K theKey, Supplier<? extends V> theValue) {
return null;
}
@Override
public Duration getExpiryForUpdate(K theKey, Supplier<? extends V> theOldValue, V theNewValue) {
return theNewValue.getTimeToLiveDuration();
}
}
然后你有正常的代碼,但有一些重要的行:
public class TestEhCache {
private static final String CACHE_TIER_HEAP = "OnHeap";
public static void main(String[] args) {
StatisticsService statisticsService = new DefaultStatisticsService();
myCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
.using(statisticsService)
.build();
//we init it here, not with boolean in build()
myCacheManager.init();
// Beware, the items are not expiring automatically, there are more mechanism in place for checking the expiration
// For instance the expiration is checked at get time
// for more details see the documentation from the version 2.8
// here: https://www.ehcache.org/documentation/2.8/apis/cache-event-listeners.html
// Unfortunately for the version 3.x doesn't exist a detailed depiction, but in main the procedure is the same
//
// Ehcache 2.8 documentation:
// Elements are checked for expiry in Ehcache at the following times:
//
// When a get request is made
// When an element is spooled to the diskStore in accordance with a MemoryStore eviction policy
// In the DiskStore when the expiry thread runs, which by default is
// net.sf.ehcache.Cache#DEFAULT_EXPIRY_THREAD_INTERVAL_SECONDS
CustomExpiryPolicy<String,EhcacheValue<?>> expiryPolicy = new CustomExpiryPolicy<String,EhcacheValue<?>>();
ResourcePools resourcePools = ResourcePoolsBuilder.newResourcePoolsBuilder().heap(2000L, EntryUnit.ENTRIES).build();
@SuppressWarnings("unchecked")
Class<EhcacheValue<?>> myEhcacheValue = (Class<EhcacheValue<?>>)(Class<?>)EhcacheValue.class;
CacheConfiguration<String,EhcacheValue<?>> cacheConfiguration = CacheConfigurationBuilder
.newCacheConfigurationBuilder(String.class, myEhcacheValue, resourcePools)
.withExpiry(expiryPolicy)
//.withService(new StoreStatisticsConfiguration(true)) // explicitly enable statistics, it seems is not needed
.build();
myCache = myCacheManager.createCache("myCache", cacheConfiguration);
myCacheStatistics = statisticsService.getCacheStatistics("myCache");
long cacheEntriesNr = myCacheStatistics.getTierStatistics().get(CACHE_TIER_HEAP).getMappings();
//nb element in heap tier
long sizeEntriesByStatistics = myCacheStatistics.getTierStatistics().get("OnHeap").getMappings();
//size of the tier in memory, when you set memory limits, not in this case
//long sizeBytesByStatistics = myCacheStatistics.getTierStatistics().get("OnHeap").getOccupiedByteSize();
long getsCnt = myCacheStatistics.getCacheGets();
long putsCnt = myCacheStatistics.getCachePuts();
long removalsCnt = myCacheStatistics.getCacheRemovals();
long missesCnt = myCacheStatistics.getCacheMisses();
long evictionsCnt = myCacheStatistics.getCacheEvictions();
long crtExpiredCnt = myCacheStatistics.getCacheExpirations();
System.out.println("getsCnt = "+getsCnt);
System.out.println("putsCnt = "+putsCnt);
System.out.println("removalsCnt = "+removalsCnt);
System.out.println("missesCnt = "+missesCnt);
System.out.println("evictionsCnt = "+evictionsCnt);
System.out.println("expiredCnt = "+expiredCnt);
System.out.println("hitPercentage = "+hitPercentage);
System.out.println("missPercentage = "+missPercentage);
System.out.println("Computed number of items in cache = "+(putsCnt-removalsCnt-expiredCnt-evictionsCnt));
}
@SuppressWarnings("unchecked")
// we are aware about the unchecked cast - it is a desired behavior.
// Cache can store objects of various types, so compile time type safety cannot be achieved easily.
// We'll get runtime ClassCastException if cache is used incorrectly.
public static <T> T get(String key) {
EhcacheValue<T> ehcacheValue = (EhcacheValue<T>)myCache.get(key);
return (T) (ehcacheValue!=null?ehcacheValue.getObject():null);
}
// we are aware about the unchecked cast - it is a desired behavior.
// Cache can store objects of various types, so compile time type safety cannot be achieved easily.
// We'll get runtime ClassCastException if cache is used incorrectly.
public static <T extends Object> T put(String key, T value, int timeToLiveInSeconds) {
if (key == null) {
throw new AssertionError("Key must not be null!");
}
if (value != null) {
EhcacheValue<T> ehcacheValue = new EhcacheValue<T>(value, Duration.of(60, ChronoUnit.SECONDS));
myCache.put(key, ehcacheValue);
return value;
} else {
return null;
}
}
}
對於 EhCache 3.3.1 版, groupId:org.ehcache,artifactId:ehcache
,以下有效!
CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().withCache("AllCache",
CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,
ResourcePoolsBuilder.heap(100))
.withExpiry(Expirations.timeToLiveExpiration(new Duration(86400, TimeUnit.SECONDS)))
.build()).build(true);
Cache<String, String> allCache = cacheManager.getCache("AllCache", String.class, String.class);
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.