/** Copies the configuration and overlays it on top of the default settings. */ @SuppressWarnings("PMD.AccessorMethodGeneration") private <K, V> CaffeineConfiguration<K, V> resolveConfigurationFor( Configuration<K, V> configuration) { if (configuration instanceof CaffeineConfiguration<?, ?>) { return new CaffeineConfiguration<>((CaffeineConfiguration<K, V>) configuration); } CaffeineConfiguration<K, V> template = TypesafeConfigurator.defaults(rootConfig); if (configuration instanceof CompleteConfiguration<?, ?>) { CompleteConfiguration<K, V> complete = (CompleteConfiguration<K, V>) configuration; template.setReadThrough(complete.isReadThrough()); template.setWriteThrough(complete.isWriteThrough()); template.setManagementEnabled(complete.isManagementEnabled()); template.setStatisticsEnabled(complete.isStatisticsEnabled()); template.getCacheEntryListenerConfigurations() .forEach(template::removeCacheEntryListenerConfiguration); complete.getCacheEntryListenerConfigurations() .forEach(template::addCacheEntryListenerConfiguration); template.setCacheLoaderFactory(complete.getCacheLoaderFactory()); template.setCacheWriterFactory(complete.getCacheWriterFactory()); template.setExpiryPolicyFactory(complete.getExpiryPolicyFactory()); } template.setTypes(configuration.getKeyType(), configuration.getValueType()); template.setStoreByValue(configuration.isStoreByValue()); return template; }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CacheEntryRemovedListener<Integer, Integer> listener = events -> removed.incrementAndGet(); CaffeineConfiguration<Integer, Integer> configuration = new CaffeineConfiguration<>(); configuration.setMaximumSize(OptionalLong.of(MAXIMUM)); CacheEntryListenerConfiguration<Integer, Integer> listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(() -> listener, /* filterFactory */ null, /* isOldValueRequired */ false, /* isSynchronous */ true); configuration.addCacheEntryListenerConfiguration(listenerConfiguration); configuration.setExecutorFactory(MoreExecutors::directExecutor); configuration.setExpiryFactory(Optional.of(() -> expiry)); configuration.setTickerFactory(() -> ticker::read); return configuration; }
/** Determines if the cache should operate in read through mode. */ private boolean isReadThrough() { return config.isReadThrough() && (config.getCacheLoaderFactory() != null); }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CaffeineConfiguration<Integer, Integer> configuration = new CaffeineConfiguration<>(); configuration.setExpiryFactory(Optional.of(() -> expiry)); configuration.setTickerFactory(() -> ticker::read); return configuration; }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CaffeineConfiguration<Integer, Integer> config = new CaffeineConfiguration<>(); config.setExpiryPolicyFactory(() -> new CreatedExpiryPolicy(Duration.FIVE_MINUTES)); config.setCacheLoaderFactory(MapLoader::new); config.setCacheWriterFactory(MapWriter::new); config.setTickerFactory(() -> ticker::read); config.setMaximumSize(OptionalLong.of(200)); config.setWriteThrough(true); config.setReadThrough(true); return config; }
static void checkTestCache(CaffeineConfiguration<?, ?> config) { checkStoreByValue(config); checkListener(config); assertThat(config.getKeyType(), is(Object.class)); assertThat(config.getValueType(), is(Object.class)); assertThat(config.getCacheLoaderFactory().create(), instanceOf(TestCacheLoader.class)); assertThat(config.getCacheWriter(), instanceOf(TestCacheWriter.class)); assertThat(config.isStatisticsEnabled(), is(true)); assertThat(config.isManagementEnabled(), is(true)); checkSize(config); checkRefresh(config); checkLazyExpiration(config); checkEagerExpiration(config); }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CacheEntryRemovedListener<Integer, Integer> listener = events -> removedWeight.addAndGet(Iterables.getOnlyElement(events).getValue()); CaffeineConfiguration<Integer, Integer> configuration = new CaffeineConfiguration<>(); configuration.setMaximumWeight(OptionalLong.of(MAXIMUM)); configuration.setWeigherFactory(Optional.of(() -> (key, value) -> value)); CacheEntryListenerConfiguration<Integer, Integer> listenerConfiguration = new MutableCacheEntryListenerConfiguration<Integer, Integer>(() -> listener, /* filterFactory */ null, /* isOldValueRequired */ true, /* isSynchronous */ true); configuration.addCacheEntryListenerConfiguration(listenerConfiguration); configuration.setExecutorFactory(MoreExecutors::directExecutor); return configuration; }
@SuppressWarnings({"PMD.ExcessiveParameterList", "NullAway"}) public CacheProxy(String name, Executor executor, CacheManager cacheManager, CaffeineConfiguration<K, V> configuration, com.github.benmanes.caffeine.cache.Cache<K, Expirable<V>> cache, EventDispatcher<K, V> dispatcher, Optional<CacheLoader<K, V>> cacheLoader, ExpiryPolicy expiry, Ticker ticker, JCacheStatisticsMXBean statistics) { this.configuration = requireNonNull(configuration); this.cacheManager = requireNonNull(cacheManager); this.cacheLoader = requireNonNull(cacheLoader); this.dispatcher = requireNonNull(dispatcher); this.statistics = requireNonNull(statistics); this.executor = requireNonNull(executor); this.expiry = requireNonNull(expiry); this.ticker = requireNonNull(ticker); this.cache = requireNonNull(cache); this.name = requireNonNull(name); copier = configuration.isStoreByValue() ? configuration.getCopierFactory().create() : Copier.identity(); writer = configuration.hasCacheWriter() ? configuration.getCacheWriter() : DisabledCacheWriter.get(); cacheMXBean = new JCacheMXBean(this); }
Builder(String cacheName, CaffeineConfiguration<K, V> config) { this.config = config; this.cacheName = cacheName; this.caffeine = Caffeine.newBuilder(); this.statistics = new JCacheStatisticsMXBean(); this.ticker = config.getTickerFactory().create(); this.executor = config.getExecutorFactory().create(); this.expiryPolicy = config.getExpiryPolicyFactory().create(); this.dispatcher = new EventDispatcher<>(executor); caffeine.executor(executor); config.getCacheEntryListenerConfigurations().forEach(dispatcher::register); }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CacheEntryRemovedListener<Integer, Integer> listener = events -> removed.incrementAndGet(); CaffeineConfiguration<Integer, Integer> configuration = new CaffeineConfiguration<>(); configuration.setMaximumSize(OptionalLong.of(MAXIMUM)); CacheEntryListenerConfiguration<Integer, Integer> listenerConfiguration = new MutableCacheEntryListenerConfiguration<Integer, Integer>(() -> listener, /* filterFactory */ null, /* isOldValueRequired */ false, /* isSynchronous */ true); configuration.addCacheEntryListenerConfiguration(listenerConfiguration); configuration.setExecutorFactory(MoreExecutors::directExecutor); return configuration; }
@Override protected CaffeineConfiguration<Integer, Integer> getConfiguration() { CaffeineConfiguration<Integer, Integer> configuration = new CaffeineConfiguration<>(); configuration.setExpiryPolicyFactory(() -> new ModifiedExpiryPolicy( new Duration(TimeUnit.MILLISECONDS, EXPIRY_DURATION))); configuration.setTickerFactory(() -> ticker::read); return configuration; }
static void checkStoreByValue(CaffeineConfiguration<?, ?> config) { assertThat(config.isStoreByValue(), is(true)); assertThat(config.getCopierFactory().create(), instanceOf(JavaSerializationCopier.class)); }
static void checkEagerExpiration(CaffeineConfiguration<?, ?> config) { assertThat(config.getExpireAfterWrite().getAsLong(), is(TimeUnit.MINUTES.toNanos(1))); assertThat(config.getExpireAfterAccess().getAsLong(), is(TimeUnit.MINUTES.toNanos(5))); }
/** Configures the write expiration and returns if set. */ private boolean configureExpireVariably() { config.getExpiryFactory().ifPresent(factory -> { Expiry<K, V> expiry = factory.create(); caffeine.expireAfter(new Expiry<K, Expirable<V>>() { @Override public long expireAfterCreate(K key, Expirable<V> expirable, long currentTime) { return expiry.expireAfterCreate(key, expirable.get(), currentTime); } @Override public long expireAfterUpdate(K key, Expirable<V> expirable, long currentTime, long currentDuration) { return expiry.expireAfterUpdate(key, expirable.get(), currentTime, currentDuration); } @Override public long expireAfterRead(K key, Expirable<V> expirable, long currentTime, long currentDuration) { return expiry.expireAfterRead(key, expirable.get(), currentTime, currentDuration); } }); }); return config.getExpireAfterWrite().isPresent(); }
@Test public void defaults() { CaffeineConfiguration<Integer, Integer> defaults = TypesafeConfigurator.defaults(ConfigFactory.load()); assertThat(defaults.getMaximumSize(), is(OptionalLong.of(500))); assertThat(defaults.getKeyType(), is(Object.class)); assertThat(defaults.getValueType(), is(Object.class)); }
@Override public void registerCacheEntryListener( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { requireNotClosed(); configuration.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); dispatcher.register(cacheEntryListenerConfiguration); }
Configurator(Config config, String cacheName) { this.root = requireNonNull(config); this.configuration = new CaffeineConfiguration<>(); this.customized = root.getConfig("caffeine.jcache." + cacheName); this.merged = customized.withFallback(root.getConfig("caffeine.jcache.default")); }
/** Creates a cache that does not read through on a cache miss. */ private CacheProxy<K, V> newCacheProxy() { Optional<CacheLoader<K, V>> cacheLoader = Optional.ofNullable(config.getCacheLoaderFactory()).map(Factory::create); return new CacheProxy<>(cacheName, executor, cacheManager, config, caffeine.build(), dispatcher, cacheLoader, expiryPolicy, ticker, statistics); }
/** Configures the maximum size and returns if set. */ private boolean configureMaximumSize() { if (config.getMaximumSize().isPresent()) { caffeine.maximumSize(config.getMaximumSize().getAsLong()); } return config.getMaximumSize().isPresent(); }
/** Configures the access expiration and returns if set. */ private boolean configureExpireAfterAccess() { if (config.getExpireAfterAccess().isPresent()) { caffeine.expireAfterAccess(config.getExpireAfterAccess().getAsLong(), TimeUnit.NANOSECONDS); } return config.getExpireAfterAccess().isPresent(); }