public void setStatisticsEnabled(boolean enabled) { delegate.setStatisticsEnabled(enabled); }
public void setStatisticsEnabled(boolean enabled) { delegate.setStatisticsEnabled(enabled); }
/** See {@link MutableConfiguration#setStatisticsEnabled}. */ public void setStatisticsEnabled(boolean enabled) { delegate.setStatisticsEnabled(enabled); }
/** {@inheritDoc} */ @Override public CacheConfiguration<K, V> setStatisticsEnabled(boolean enabled) { super.setStatisticsEnabled(enabled); return this; }
/** * Create a simple configuration that enable statistics via the JCache programmatic configuration API. * <p> * Within the configuration object that is provided by the JCache API standard, there is only a very limited set of * configuration options. The really relevant configuration options (like the size limit) must be set via a * configuration mechanism that is provided by the selected JCache implementation. */ private javax.cache.configuration.Configuration<Object, Object> cacheConfiguration() { return new MutableConfiguration<>().setStatisticsEnabled(true); }
private MutableConfiguration<Object, Object> config() { return new MutableConfiguration<>().setStoreByValue(false) .setManagementEnabled(true).setStatisticsEnabled(true); }
@BeforeClass public void beforeClass() { final CachingProvider provider = Caching.getCachingProvider(PROVIDER_NAME); cacheManager = provider.getCacheManager(); cacheManager.destroyCache("cache-not-in-config-file"); cacheConfig = new MutableConfiguration<>(); cacheConfig.setTypes(String.class, String.class); cacheConfig.setStatisticsEnabled(true); }
@Test public void testManagementDisabledOverriddenFromTemplate() throws Exception { CacheManager cacheManager = provider.getCacheManager(getClass().getResource("/ehcache-107-mbeans-template-config.xml") .toURI(), provider.getDefaultClassLoader()); MutableConfiguration<Long, String> configuration = new MutableConfiguration<>(); configuration.setTypes(Long.class, String.class); configuration.setManagementEnabled(false); configuration.setStatisticsEnabled(false); Cache<Long, String> cache = cacheManager.createCache("enables-mbeans", configuration); @SuppressWarnings("unchecked") Eh107Configuration<Long, String> eh107Configuration = cache.getConfiguration(Eh107Configuration.class); assertThat(eh107Configuration.isManagementEnabled(), is(true)); assertThat(eh107Configuration.isStatisticsEnabled(), is(true)); assertThat(isMbeanRegistered("enables-mbeans", MBEAN_MANAGEMENT_TYPE), is(true)); assertThat(isMbeanRegistered("enables-mbeans", MBEAN_STATISTICS_TYPE), is(true)); }
@Test public void testManagementEnabledOverriddenFromTemplate() throws Exception { CacheManager cacheManager = provider.getCacheManager(getClass().getResource("/ehcache-107-mbeans-template-config.xml") .toURI(), provider.getDefaultClassLoader()); MutableConfiguration<Long, String> configuration = new MutableConfiguration<>(); configuration.setTypes(Long.class, String.class); configuration.setManagementEnabled(true); configuration.setStatisticsEnabled(true); Cache<Long, String> cache = cacheManager.createCache("disables-mbeans", configuration); @SuppressWarnings("unchecked") Eh107Configuration<Long, String> eh107Configuration = cache.getConfiguration(Eh107Configuration.class); assertThat(eh107Configuration.isManagementEnabled(), is(false)); assertThat(eh107Configuration.isStatisticsEnabled(), is(false)); assertThat(isMbeanRegistered("disables-mbeans", MBEAN_MANAGEMENT_TYPE), is(false)); assertThat(isMbeanRegistered("disables-mbeans", MBEAN_STATISTICS_TYPE), is(false)); }
@Test public void basicJsr107StillWorks() throws Exception { CacheManager cacheManager = provider.getCacheManager(); MutableConfiguration<Long, String> configuration = new MutableConfiguration<>(); configuration.setTypes(Long.class, String.class); configuration.setManagementEnabled(true); configuration.setStatisticsEnabled(true); Cache<Long, String> cache = cacheManager.createCache("cache", configuration); @SuppressWarnings("unchecked") Eh107Configuration<Long, String> eh107Configuration = cache.getConfiguration(Eh107Configuration.class); assertThat(eh107Configuration.isManagementEnabled(), is(true)); assertThat(eh107Configuration.isStatisticsEnabled(), is(true)); assertThat(isMbeanRegistered("cache", MBEAN_MANAGEMENT_TYPE), is(true)); assertThat(isMbeanRegistered("cache", MBEAN_STATISTICS_TYPE), is(true)); } }
public JCache(URL url) { String method = url.getParameter(Constants.METHOD_KEY, ""); String key = url.getAddress() + "." + url.getServiceKey() + "." + method; // jcache parameter is the full-qualified class name of SPI implementation String type = url.getParameter("jcache"); CachingProvider provider = StringUtils.isEmpty(type) ? Caching.getCachingProvider() : Caching.getCachingProvider(type); CacheManager cacheManager = provider.getCacheManager(); Cache<Object, Object> cache = cacheManager.getCache(key); if (cache == null) { try { //configure the cache MutableConfiguration config = new MutableConfiguration<Object, Object>() .setTypes(Object.class, Object.class) .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MILLISECONDS, url.getMethodParameter(method, "cache.write.expire", 60 * 1000)))) .setStoreByValue(false) .setManagementEnabled(true) .setStatisticsEnabled(true); cache = cacheManager.createCache(key, config); } catch (CacheException e) { // concurrent cache initialization cache = cacheManager.getCache(key); } } this.store = cache; }
public JCache(URL url) { String method = url.getParameter(Constants.METHOD_KEY, ""); String key = url.getAddress() + "." + url.getServiceKey() + "." + method; // jcache parameter is the full-qualified class name of SPI implementation String type = url.getParameter("jcache"); CachingProvider provider = StringUtils.isEmpty(type) ? Caching.getCachingProvider() : Caching.getCachingProvider(type); CacheManager cacheManager = provider.getCacheManager(); Cache<Object, Object> cache = cacheManager.getCache(key); if (cache == null) { try { //configure the cache MutableConfiguration config = new MutableConfiguration<Object, Object>() .setTypes(Object.class, Object.class) .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MILLISECONDS, url.getMethodParameter(method, "cache.write.expire", 60 * 1000)))) .setStoreByValue(false) .setManagementEnabled(true) .setStatisticsEnabled(true); cache = cacheManager.createCache(key, config); } catch (CacheException e) { // concurrent cache initialization cache = cacheManager.getCache(key); } } this.store = cache; }
/** {@inheritDoc} */ @Override public CacheConfiguration<K, V> setStatisticsEnabled(boolean enabled) { super.setStatisticsEnabled(enabled); return this; }
private Configuration<Object, Object> createCacheConfiguration() { // Create a cache using infinite heap. A real application will want to use an // implementation dependent configuration that will better fit your needs return new MutableConfiguration<>().setStatisticsEnabled(true); } }
/** * Initialize cache configuration, could be overriden. * * @return * cache default configuration */ protected MutableConfiguration< String, Feature> getFeatureCacheConfiguration() { MutableConfiguration<String, Feature> featuresCacheConfig = new MutableConfiguration<>(); featuresCacheConfig.setTypes(String.class, Feature.class); featuresCacheConfig.setStoreByValue(true); featuresCacheConfig.setStatisticsEnabled(false); return featuresCacheConfig; }
/** * Initialize cache configuration, could be overriden. * * @return * cache default configuration */ @SuppressWarnings("rawtypes") protected MutableConfiguration< String, Property> getPropertyCacheConfiguration() { MutableConfiguration<String, Property> propertiesCacheConfig = new MutableConfiguration<>(); propertiesCacheConfig.setTypes(String.class, Property.class); propertiesCacheConfig.setStoreByValue(true); propertiesCacheConfig.setStatisticsEnabled(false); return propertiesCacheConfig; }
private Cache<String, DomainObject> getCache(CacheManager cacheManager1) { MutableConfiguration<String, DomainObject> config = new MutableConfiguration<String, DomainObject>(); config.setStoreByValue(true) .setTypes(String.class, DomainObject.class) .setStatisticsEnabled(false); return cacheManager1.createCache("cache", config); }
private <T> MutableConfiguration<String, T> configure(final MutableConfiguration<String, T> configuration, final OAuth2Options opts) { ofNullable(opts.getJcacheLoader()) .map(n -> lookup(CacheLoader.class, n)) .ifPresent(l -> configuration.setCacheLoaderFactory(new FactoryBuilder.SingletonFactory<CacheLoader<String, T>>(l))); ofNullable(opts.getJcacheWriter()) .map(n -> lookup(CacheWriter.class, n)) .ifPresent(w -> configuration.setCacheWriterFactory(new FactoryBuilder.SingletonFactory<CacheWriter<String, T>>(w))); return configuration .setStoreByValue(opts.isJcacheStoreValue()) .setStatisticsEnabled(opts.isJcacheStatistics()) .setManagementEnabled(opts.isJcacheJmx()); }
<K, T> Configuration<K, T> createConfiguration(final CacheSizeManager<K, T> listener) { return new MutableConfiguration<K, T>() .setStoreByValue(false) .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(SECONDS, cacheExpiry))) .setManagementEnabled(cacheManagement) .setStatisticsEnabled(cacheStatistics) .addCacheEntryListenerConfiguration(new MutableCacheEntryListenerConfiguration<>( new FactoryBuilder.SingletonFactory<>(listener), null, false, false)); }
@Test public void testEternalExpiryPolicy() { EternalExpiryPolicy policy = new EternalExpiryPolicy(); EternalExpiryPolicy policy2 = new EternalExpiryPolicy(); assertEquals(policy, policy2); assertEquals(policy.hashCode(), policy2.hashCode()); MutableConfiguration<Integer, Integer> config = new MutableConfiguration<>(); config.setExpiryPolicyFactory(FactoryBuilder.factoryOf(policy)).setStatisticsEnabled(true); Cache<Integer, Integer> cache = cacheManager.createCache(getTestCacheName(), config); assertEquals(ETERNAL, policy.getExpiryForCreation()); assertNull(policy.getExpiryForAccess()); assertNull(policy.getExpiryForUpdate()); }