Java MutableConfiguration.setStoreByValue方法代码示例

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testCacheManagerWithCustomInvalidProperties()
    throws Exception
{
    Properties properties = new Properties();

    properties.setProperty("unknownProperty", "true");

    try (CacheManager cacheManager = cachingProvider.getCacheManager(null, null, properties);)
    {
        assertNotNull(cacheManager);

        MutableConfiguration configuration = new MutableConfiguration();

        configuration.setStoreByValue(false);

        cacheManager.createCache("test", configuration);
    }
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test
public void testCreateCacheWithModifiedExpiryPolicy()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(Duration.ONE_DAY));

    Cache cache = cacheManager.createCache("cache", configuration);

    CompleteConfiguration actualConfiguration =
        (CompleteConfiguration) cache.getConfiguration(CompleteConfiguration.class);

    assertEquals(ModifiedExpiryPolicy.factoryOf(Duration.ONE_DAY), actualConfiguration.getExpiryPolicyFactory());
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test
public void testCreateCacheWithTouchedExpiryPolicy()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setExpiryPolicyFactory(TouchedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));

    Cache cache = cacheManager.createCache("cache", configuration);

    CompleteConfiguration actualConfiguration =
        (CompleteConfiguration) cache.getConfiguration(CompleteConfiguration.class);

    assertEquals(TouchedExpiryPolicy.factoryOf(Duration.ONE_MINUTE), actualConfiguration.getExpiryPolicyFactory());
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
Configuration getOrCreateCacheConfiguration() {
    if (configuration.getCacheConfiguration() != null) {
        return configuration.getCacheConfiguration();
    }

    MutableConfiguration mutableConfiguration = new MutableConfiguration();
    if (configuration.getCacheLoaderFactory() != null) {
        mutableConfiguration.setCacheLoaderFactory(configuration.getCacheLoaderFactory());
    }
    if (configuration.getCacheWriterFactory() != null) {
        mutableConfiguration.setCacheWriterFactory(configuration.getCacheWriterFactory());
    }
    if (configuration.getExpiryPolicyFactory() != null) {
        mutableConfiguration.setExpiryPolicyFactory(configuration.getExpiryPolicyFactory());
    }

    mutableConfiguration.setManagementEnabled(configuration.isManagementEnabled());
    mutableConfiguration.setStatisticsEnabled(configuration.isStatisticsEnabled());
    mutableConfiguration.setReadThrough(configuration.isReadThrough());
    mutableConfiguration.setStoreByValue(configuration.isStoreByValue());

    return mutableConfiguration;
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Override public <K, V> CompleteConfiguration<K, V> createConfiguration( Class<K> keyType, Class<V> valueType,
                                                                         Map<String, String> properties ) {
  MutableConfiguration<K, V> configuration = new MutableConfiguration<K, V>();
  configuration.setTypes( keyType, valueType );

  if ( properties.containsKey( CONFIG_TTL ) ) {
    Long ttl = Longs.tryParse( Strings.nullToEmpty( properties.get( CONFIG_TTL ) ) );
    Preconditions.checkArgument( ttl != null, "Template config error", CONFIG_TTL );

    Optional<ExpiryFunction> expiryFunction;
    if ( properties.containsKey( CONFIG_TTL_RESET ) ) {
      expiryFunction = Enums.getIfPresent( ExpiryFunction.class, properties.get( CONFIG_TTL_RESET ) );
    } else {
      expiryFunction = Optional.of( CONFIG_TTL_RESET_DEFAULT );
    }
    Preconditions.checkArgument( expiryFunction.isPresent(), "Template config error", CONFIG_TTL_RESET );

    configuration.setExpiryPolicyFactory( expiryFunction.get().createFactory( ttl ) );
  }
  if ( properties.containsKey( CONFIG_STORE_BY_VALUE ) ) {
    configuration.setStoreByValue( Boolean.valueOf( properties.get( CONFIG_STORE_BY_VALUE ) ) );
  }
  return configuration;
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
/**
 * Prep cache configuration.
 *
 * @param expiryDuration the expiry duration
 * @return the mutable configuration
 */
protected static MutableConfiguration<String, Map<String, Object>> createCacheConfiguration(final Duration expiryDuration) {
    final MutableConfiguration<String, Map<String, Object>> config = new MutableConfiguration<>();
    config.setStatisticsEnabled(true);
    config.setManagementEnabled(true);
    config.setStoreByValue(true);
    config.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(expiryDuration));
    return config;
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test
public void testExpiration() throws InterruptedException, IllegalArgumentException, URISyntaxException, FailedToStartRedisException, IOException {
    RedisProcess runner = new RedisRunner()
            .nosave()
            .randomDir()
            .port(6311)
            .run();

    MutableConfiguration<String, String> config = new MutableConfiguration<>();
    config.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 1)));
    config.setStoreByValue(true);
    
    URI configUri = getClass().getResource("redisson-jcache.json").toURI();
    Cache<String, String> cache = Caching.getCachingProvider().getCacheManager(configUri, null)
            .createCache("test", config);

    CountDownLatch latch = new CountDownLatch(1);
    
    String key = "123";
    ExpiredListener clientListener = new ExpiredListener(latch, key, "90");
    MutableCacheEntryListenerConfiguration<String, String> listenerConfiguration = 
            new MutableCacheEntryListenerConfiguration<String, String>(FactoryBuilder.factoryOf(clientListener), null, true, true);
    cache.registerCacheEntryListener(listenerConfiguration);

    cache.put(key, "90");
    Assert.assertNotNull(cache.get(key));
    
    latch.await();
    
    Assert.assertNull(cache.get(key));
    
    cache.close();
    runner.stop();
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = UnsupportedOperationException.class)
public void testCreateStoryByValueCache()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(true);

    cacheManager.createCache("cache", configuration);
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testCreateReadThroughCacheWithInvalidConfiguration()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setReadThrough(true);

    cacheManager.createCache("cache", configuration);
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = UnsupportedOperationException.class)
public void testCreateWriteThroughCacheWithInvalidConfiguration()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setWriteThrough(true);

    cacheManager.createCache("cache", configuration);
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = UnsupportedOperationException.class)
public void testCreateCacheWithUnsupportedAccessedExpiryPolicy()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(Duration.ZERO));

    cacheManager.createCache("cache", configuration);
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test(expected = UnsupportedOperationException.class)
public void testCreateCacheWithUnsupportedCreatedExpiryPolicy()
{
    CacheManager cacheManager = cachingProvider.getCacheManager();

    MutableConfiguration<Number, Number> configuration = new MutableConfiguration<>();

    configuration.setStoreByValue(false);
    configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ZERO));

    cacheManager.createCache("cache", configuration);
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Bean
public CacheManager jCacheManager() {
	CacheManager cacheManager = this.cachingProvider.getCacheManager();
	MutableConfiguration<Object, Object> mutableConfiguration = new MutableConfiguration<Object, Object>();
	mutableConfiguration.setStoreByValue(false);  // otherwise value has to be Serializable
	cacheManager.createCache("testCache", mutableConfiguration);
	cacheManager.createCache("primary", mutableConfiguration);
	cacheManager.createCache("secondary", mutableConfiguration);
	return cacheManager;
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Bean
public CacheManager jCacheManager() {
    CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
    MutableConfiguration<Object, Object> mutableConfiguration = new MutableConfiguration<Object, Object>();
    mutableConfiguration.setStoreByValue(false);  // otherwise value has to be Serializable
    cacheManager.createCache("primary", new JCacheConfiguration<Object, Object>(mutableConfiguration));
    return cacheManager;
}
 

import javax.cache.configuration.MutableConfiguration; //导入方法依赖的package包/类
@Test
public void testCustomConfiguration() throws Exception {
  boolean storeByValue = false;
  MutableConfiguration configuration = new MutableConfiguration()
      .setReadThrough(false).setWriteThrough(false).setStoreByValue(storeByValue)
      .setTypes(java.math.BigDecimal.class, java.awt.Color.class)
      .setManagementEnabled(true).setStatisticsEnabled(false);
  Cache cache = null;
  try
  {
    cache = getCacheManager().createCache("customCache", configuration);
  } catch (UnsupportedOperationException e) {
    storeByValue = true;
    configuration.setStoreByValue(storeByValue);
    cache = getCacheManager().createCache("customCache", configuration);
  }
  assertEquals("java.math.BigDecimal", lookupManagementAttribute(cache, CacheConfiguration, "KeyType"));
  assertEquals("java.awt.Color", lookupManagementAttribute(cache, CacheConfiguration, "ValueType"));
  assertEquals(false, lookupManagementAttribute(cache, CacheConfiguration, "ReadThrough"));
  assertEquals(false, lookupManagementAttribute(cache, CacheConfiguration, "WriteThrough"));
  assertEquals(storeByValue, lookupManagementAttribute(cache, CacheConfiguration, "StoreByValue"));
  assertEquals(false, lookupManagementAttribute(cache, CacheConfiguration, "StatisticsEnabled"));
  assertEquals(true, lookupManagementAttribute(cache, CacheConfiguration, "ManagementEnabled"));

  //this used to just call close() but that does not work if an implementation maintains statistics on the cluster.
  cache.getCacheManager().destroyCache("customCache");
}