/** * Create a new CaffeineCache instance for the specified cache name. * @param name the name of the cache * @return the Spring CaffeineCache adapter (or a decorator thereof) */ protected Cache createCaffeineCache(String name) { return new CaffeineCache(name, createNativeCaffeineCache(name), isAllowNullValues()); }
/** * Specify whether to accept and convert {@code null} values for all caches * in this cache manager. * <p>Default is "true", despite Caffeine itself not supporting {@code null} values. * An internal holder object will be used to store user-level {@code null}s. */ public void setAllowNullValues(boolean allowNullValues) { if (this.allowNullValues != allowNullValues) { this.allowNullValues = allowNullValues; refreshKnownCaches(); } }
/** * Construct a static CaffeineCacheManager, * managing caches for the specified cache names only. */ public CaffeineCacheManager(String... cacheNames) { setCacheNames(Arrays.asList(cacheNames)); }
@Test public void setCacheNameNullRestoreDynamicMode() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); assertNull(cm.getCache("someCache")); cm.setCacheNames(null); assertNotNull(cm.getCache("someCache")); }
@Test public void changeCacheLoaderRecreateCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); Cache cache1 = cm.getCache("c1"); CacheLoader<Object, Object> loader = mockCacheLoader(); cm.setCacheLoader(loader); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x != cache1); cm.setCacheLoader(loader); // Set same instance Cache cache1xx = cm.getCache("c1"); assertSame(cache1x, cache1xx); }
@Before public void setUp() { nativeCache = Caffeine.newBuilder().build(); cache = new CaffeineCache(CACHE_NAME, nativeCache); com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCacheNoNull = Caffeine.newBuilder().build(); cacheNoNull = new CaffeineCache(CACHE_NAME_NO_NULL, nativeCacheNoNull, false); }
@Test public void changeCacheSpecificationRecreateCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); Cache cache1 = cm.getCache("c1"); cm.setCacheSpecification("maximumSize=10"); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x != cache1); }
@SuppressWarnings("unchecked") @Override @Nullable public <T> T get(Object key, final Callable<T> valueLoader) { return (T) fromStoreValue(this.cache.get(key, new LoadFunction(valueLoader))); }
@Override @Nullable public ValueWrapper putIfAbsent(Object key, @Nullable final Object value) { PutIfAbsentFunction callable = new PutIfAbsentFunction(value); Object result = this.cache.get(key, callable); return (callable.called ? null : toValueWrapper(result)); }
/** * Set the Caffeine to use for building each individual * {@link CaffeineCache} instance. * @see #createNativeCaffeineCache * @see com.github.benmanes.caffeine.cache.Caffeine#build() */ public void setCaffeine(Caffeine<Object, Object> caffeine) { Assert.notNull(caffeine, "Caffeine must not be null"); doSetCaffeine(caffeine); }
/** * Create the known caches again with the current state of this manager. */ private void refreshKnownCaches() { for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) { entry.setValue(createCaffeineCache(entry.getKey())); } }
@Override public void put(Object key, @Nullable Object value) { this.cache.put(key, toStoreValue(value)); }
@Test public void testPutIfAbsentNullValue() throws Exception { CaffeineCache cache = getCache(); Object key = new Object(); Object value = null; assertNull(cache.get(key)); assertNull(cache.putIfAbsent(key, value)); assertEquals(value, cache.get(key).get()); Cache.ValueWrapper wrapper = cache.putIfAbsent(key, "anotherValue"); assertNotNull(wrapper); // A value is set but is 'null' assertEquals(null, wrapper.get()); assertEquals(value, cache.get(key).get()); // not changed }
@Override protected CaffeineCache getCache() { return getCache(true); }
/** * Create a new CaffeineCache instance for the specified cache name. * @param name the name of the cache * @return the Spring CaffeineCache adapter (or a decorator thereof) */ protected Cache createCaffeineCache(String name) { return new CaffeineCache(name, createNativeCaffeineCache(name), isAllowNullValues()); }
private void doSetCaffeine(Caffeine<Object, Object> cacheBuilder) { if (!ObjectUtils.nullSafeEquals(this.cacheBuilder, cacheBuilder)) { this.cacheBuilder = cacheBuilder; refreshKnownCaches(); } }
/** * Set the {@link CaffeineSpec} to use for building each individual * {@link CaffeineCache} instance. * @see #createNativeCaffeineCache * @see com.github.benmanes.caffeine.cache.Caffeine#from(CaffeineSpec) */ public void setCaffeineSpec(CaffeineSpec caffeineSpec) { doSetCaffeine(Caffeine.from(caffeineSpec)); }
@Override @Nullable public Cache getCache(String name) { Cache cache = this.cacheMap.get(name); if (cache == null && this.dynamic) { synchronized (this.cacheMap) { cache = this.cacheMap.get(name); if (cache == null) { cache = createCaffeineCache(name); this.cacheMap.put(name, cache); } } } return cache; }
/** * Set the Caffeine CacheLoader to use for building each individual * {@link CaffeineCache} instance, turning it into a LoadingCache. * @see #createNativeCaffeineCache * @see com.github.benmanes.caffeine.cache.Caffeine#build(CacheLoader) * @see com.github.benmanes.caffeine.cache.LoadingCache */ public void setCacheLoader(CacheLoader<Object, Object> cacheLoader) { if (!ObjectUtils.nullSafeEquals(this.cacheLoader, cacheLoader)) { this.cacheLoader = cacheLoader; refreshKnownCaches(); } }
/** * Set the Caffeine cache specification String to use for building each * individual {@link CaffeineCache} instance. The given value needs to * comply with Caffeine's {@link CaffeineSpec} (see its javadoc). * @see #createNativeCaffeineCache * @see com.github.benmanes.caffeine.cache.Caffeine#from(String) */ public void setCacheSpecification(String cacheSpecification) { doSetCaffeine(Caffeine.from(cacheSpecification)); }