@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); }
/** * Construct a static CaffeineCacheManager, * managing caches for the specified cache names only. */ public CaffeineCacheManager(String... cacheNames) { setCacheNames(Arrays.asList(cacheNames)); }
/** * 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())); } }
/** * 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()); }
@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); }
@Bean public CacheManager cacheManager() { final CaffeineCacheManager manager = new CaffeineCacheManager(); final Caffeine<Object, Object> caffeineBuilder = Caffeine.newBuilder() .expireAfterWrite(30, TimeUnit.DAYS); manager.setCaffeine(caffeineBuilder); return manager; }
@Test public void changeCaffeineRecreateCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); Cache cache1 = cm.getCache("c1"); Caffeine<Object, Object> caffeine = Caffeine.newBuilder().maximumSize(10); cm.setCaffeine(caffeine); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x != cache1); cm.setCaffeine(caffeine); // Set same instance Cache cache1xx = cm.getCache("c1"); assertSame(cache1x, cache1xx); }
@Test public void setCacheNameNullRestoreDynamicMode() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); assertNull(cm.getCache("someCache")); cm.setCacheNames(null); assertNotNull(cm.getCache("someCache")); }
@Test public void changeCaffeineSpecRecreateCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); Cache cache1 = cm.getCache("c1"); cm.setCaffeineSpec(CaffeineSpec.parse("maximumSize=10")); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x != cache1); }
@Test public void testDynamicMode() { CacheManager cm = new CaffeineCacheManager(); Cache cache1 = cm.getCache("c1"); assertTrue(cache1 instanceof CaffeineCache); Cache cache1again = cm.getCache("c1"); assertSame(cache1again, cache1); Cache cache2 = cm.getCache("c2"); assertTrue(cache2 instanceof CaffeineCache); Cache cache2again = cm.getCache("c2"); assertSame(cache2again, cache2); Cache cache3 = cm.getCache("c3"); assertTrue(cache3 instanceof CaffeineCache); Cache cache3again = cm.getCache("c3"); assertSame(cache3again, cache3); cache1.put("key1", "value1"); assertEquals("value1", cache1.get("key1").get()); cache1.put("key2", 2); assertEquals(2, cache1.get("key2").get()); cache1.put("key3", null); assertNull(cache1.get("key3").get()); cache1.evict("key3"); assertNull(cache1.get("key3")); }
/** * 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(); } }
/** * 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); }
@Test public void testStaticMode() { CaffeineCacheManager cm = new CaffeineCacheManager("c1", "c2"); Cache cache1 = cm.getCache("c1"); assertTrue(cache1 instanceof CaffeineCache); Cache cache1again = cm.getCache("c1"); assertSame(cache1again, cache1); Cache cache2 = cm.getCache("c2"); assertTrue(cache2 instanceof CaffeineCache); Cache cache2again = cm.getCache("c2"); assertSame(cache2again, cache2); Cache cache3 = cm.getCache("c3"); assertNull(cache3); assertNull(cache1.get("key3")); cm.setAllowNullValues(false); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x instanceof CaffeineCache); assertTrue(cache1x != cache1); Cache cache2x = cm.getCache("c2"); assertTrue(cache2x instanceof CaffeineCache); assertTrue(cache2x != cache2); Cache cache3x = cm.getCache("c3"); assertNull(cache3x); cm.setAllowNullValues(true); Cache cache1y = cm.getCache("c1");
/** * @param tenantAware * to get current tenant * @param size * the maximum size of the cache */ public RolloutStatusCache(final TenantAware tenantAware, final long size) { this.tenantAware = tenantAware; final Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder().maximumSize(size); final CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager(); caffeineCacheManager.setCaffeine(cacheBuilder); this.cacheManager = new TenantAwareCacheManager(caffeineCacheManager, tenantAware); }
/** * 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()); }
@Bean public CacheManager getCacheManager() { return new CaffeineCacheManager("infos", "titles", "updates", "dev"); }
/** * 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 {@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)); }
/** * @return the direct cache manager to access without tenant aware * check, cause in sometimes it's necessary to access the cache * directly without having the current tenant, e.g. initial * creation of tenant */ @Bean(name = "directCacheManager") @ConditionalOnMissingBean(name = "directCacheManager") public CacheManager directCacheManager(final CacheProperties cacheProperties) { final CaffeineCacheManager cacheManager = new CaffeineCacheManager(); if (cacheProperties.getTtl() > 0) { final Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder() .expireAfterWrite(cacheProperties.getTtl(), cacheProperties.getTtlUnit()); cacheManager.setCaffeine(cacheBuilder); } return cacheManager; }
@Test public void cacheLoaderUseLoadingCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); cm.setCacheLoader(new CacheLoader<Object, Object>() { @Override public Object load(Object key) throws Exception { if ("ping".equals(key)) { return "pong"; } throw new IllegalArgumentException("I only know ping"); } }); Cache cache1 = cm.getCache("c1"); Cache.ValueWrapper value = cache1.get("ping"); assertNotNull(value); assertEquals("pong", value.get()); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("I only know ping"); assertNull(cache1.get("foo")); }