How to use

factoryOf

method

in

javax.cache.expiry.CreatedExpiryPolicy

@Bean
public JCacheManagerCustomizer initializrCacheManagerCustomizer() {
  return (cacheManager) -> {
    cacheManager.createCache("initializr.metadata",
        config().setExpiryPolicyFactory(
            CreatedExpiryPolicy.factoryOf(Duration.TEN_MINUTES)));
    cacheManager.createCache("initializr.dependency-metadata", config());
    cacheManager.createCache("initializr.project-resources", config());
  };
}

/**
 * @throws Exception If failed.
 */
@Test
public void testZeroOnCreate() throws Exception {
  factory = CreatedExpiryPolicy.factoryOf(Duration.ZERO);
  startGrids();
  for (final Integer key : keys()) {
    log.info("Test zero duration on create, key: " + key);
    zeroOnCreate(key);
  }
}

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 protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
  IgniteConfiguration cfg = super.getConfiguration(gridName);
  CacheConfiguration ccfg = defaultCacheConfiguration();
  ccfg.setName(CACHE_NAME);
  ccfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
  ccfg.setCacheMode(CacheMode.PARTITIONED);
  ccfg.setBackups(1);
  ccfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MINUTES, 10)));
  cfg.setCacheConfiguration(ccfg);
  return cfg;
}

@Test
public void basicConfiguration() throws Exception {
 // tag::basicConfigurationExample[]
 CachingProvider provider = Caching.getCachingProvider();  // <1>
 CacheManager cacheManager = provider.getCacheManager();   // <2>
 MutableConfiguration<Long, String> configuration =
   new MutableConfiguration<Long, String>()  // <3>
     .setTypes(Long.class, String.class)   // <4>
     .setStoreByValue(false)   // <5>
     .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));  // <6>
 Cache<Long, String> cache = cacheManager.createCache("jCache", configuration); // <7>
 cache.put(1L, "one"); // <8>
 String value = cache.get(1L); // <9>
 // end::basicConfigurationExample[]
 assertThat(value, is("one"));
}

/** {@inheritDoc} */
@Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
  IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
  CacheConfiguration ccfg = new CacheConfiguration(DEFAULT_CACHE_NAME);
  ccfg.setCacheMode(cacheMode);
  ccfg.setEagerTtl(true);
  ccfg.setEvictionPolicy(new FifoEvictionPolicy(ENTRIES_LIMIT, 100));
  ccfg.setOnheapCacheEnabled(true);
  ccfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.HOURS, 12)));
  cfg.setCacheConfiguration(ccfg);
  return cfg;
}

otherConfiguration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE)); // <6>

/** {@inheritDoc} */
@Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
  IgniteConfiguration cfg = super.getConfiguration(gridName);
  CacheConfiguration ccfg = new CacheConfiguration();
  ccfg.setName(CACHE_NAME);
  ccfg.setGroupName("Group1");
  ccfg.setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL);
  ccfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
  ccfg.setAffinity(new RendezvousAffinityFunction(false, 128));
  ccfg.setBackups(2);
  ccfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 1)));
  cfg.setCacheConfiguration(ccfg);
  return cfg;
}

/** {@inheritDoc} */
@Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
  IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
  CacheConfiguration<String, Long> ccfg = new CacheConfiguration<>(DEFAULT_CACHE_NAME);
  ccfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
  ccfg.setCacheMode(CacheMode.PARTITIONED);
  ccfg.setBackups(1);
  ccfg.setReadFromBackup(true);
  ccfg.setCopyOnRead(false);
  ccfg.setName(THROTTLES_CACHE_NAME);
  Duration expiryDuration = new Duration(TimeUnit.MINUTES, 1);
  ccfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(expiryDuration));
  ccfg.setReadThrough(false);
  ccfg.setWriteThrough(true);
  ccfg.setCacheStoreFactory(new FactoryBuilder.SingletonFactory<>(new TestCacheStore()));
  cfg.setCacheConfiguration(ccfg);
  return cfg;
}

/** {@inheritDoc} */
@Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
  IgniteConfiguration cfg = super.getConfiguration(gridName);
  CacheConfiguration<Integer, Integer> ccfg =
    new CacheConfiguration<Integer, Integer>()
      .setName("config")
      .setAtomicityMode(CacheAtomicityMode.ATOMIC)
      .setBackups(0) // No need for backup, just load from the store if needed
      .setCacheStoreFactory(new CacheStoreFactory())
      .setOnheapCacheEnabled(true)
      .setEvictionPolicy(new LruEvictionPolicy(100))
      .setNearConfiguration(new NearCacheConfiguration<Integer, Integer>()
      .setNearEvictionPolicy(new LruEvictionPolicy<Integer, Integer>()));
  ccfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MINUTES, 1)))
    .setReadThrough(true)
    .setWriteThrough(false);
  cfg.setCacheConfiguration(ccfg);
  return cfg;
}

/**
 * Put entry to server node and check how its expires in client NearCache.
 *
 * @throws Exception If failed.
 */
@Test
public void testNearExpiresOnClient() throws Exception {
  if (cacheMode() != PARTITIONED)
    return;
  factory = CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 2));
  nearCache = true;
  startGrids();
  IgniteConfiguration clientCfg = getConfiguration("client").setClientMode(true);
  ((TcpDiscoverySpi)clientCfg.getDiscoverySpi()).setForceServerMode(false);
  Ignite client = startGrid("client", clientCfg);
  IgniteCache<Object, Object> cache = client.cache(DEFAULT_CACHE_NAME);
  Integer key = 1;
  // Put on server node.
  jcache(0).put(key, 1);
  // Make entry cached in client NearCache.
  assertEquals(1, cache.get(key));
  assertEquals(1, cache.localPeek(key, CachePeekMode.NEAR));
  waitExpired(key);
  // Check client NearCache.
  assertNull(cache.localPeek(key, CachePeekMode.NEAR));
}

  return;
factory = CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 1));

 @VisibleForTesting
 <K, V> javax.cache.Cache<K, V> maybeCreateCache(final String name) {
  if (Objects.equals(ACTIVE_SESSION_CACHE_NAME, name)) {
   // shiro's session cache needs to never expire:
   // http://shiro.apache.org/session-management.html#ehcache-session-cache-configuration
   return cacheHelperProvider.get().maybeCreateCache(name, EternalExpiryPolicy.factoryOf());
  }
  else {
   Time timeToLive = Optional.ofNullable(System.getProperty(name + ".timeToLive"))
     .map(Time::parse)
     .orElse(defaultTimeToLive.get());
   return cacheHelperProvider.get().maybeCreateCache(name,
     CreatedExpiryPolicy.factoryOf(new Duration(timeToLive.getUnit(), timeToLive.getValue())));
  }
 }
}

private void maybeCreateCache() {
 if (cache == null) {
  log.debug("Creating negative-cache for: {}", getRepository());
  cache = cacheHelper.maybeCreateCache(getCacheName(), NegativeCacheKey.class, Status.class,
    CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MINUTES, config.timeToLive)));
  log.debug("Created negative-cache: {}", cache);
 }
}

@Test
public void testEqualsForCreatedExpiryPolicy() {
 // added for code coverage
 ExpiryPolicy policy = CreatedExpiryPolicy.factoryOf( new Duration(TimeUnit.MILLISECONDS, 20)).create();
 assertTrue(policy.equals(policy));
 assertFalse(policy.equals(null));
 assertFalse(policy.equals("noMatchWrongClass"));
 ExpiryPolicy nullDurationPolicy = CreatedExpiryPolicy.factoryOf(null).create();
 nullDurationPolicy.hashCode();
 assertFalse(nullDurationPolicy.equals(policy));
 ExpiryPolicy nullDurationPolicy1 = CreatedExpiryPolicy.factoryOf(null).create();
 assertTrue(nullDurationPolicy.equals(nullDurationPolicy1));
}

@Override
protected void doStart() throws Exception {
 try (ODatabaseDocumentTx db = databaseInstance.get().connect()) {
  entityAdapter.register(db);
 }
 if (cache == null) {
  this.cache = cacheHelper.getOrCreate(cacheHelper.<CacheEntryKey, Long>builder()
    .name(CACHE_NAME)
    .cacheSize(cacheSize)
    .expiryFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, cacheDuration)))
    .keyType(CacheEntryKey.class)
    .valueType(Long.class)
    .persister(cacheRemovalListener));
 }
}

<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));
}

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 = type == null || type.length() == 0 ? 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;
}

@Test
public void testCreatedExpiryPolicy() {
 ExpiryPolicy policy = CreatedExpiryPolicy.factoryOf( new Duration(TimeUnit.MILLISECONDS, 20)).create();
 CreatedExpiryPolicy policy2 = new CreatedExpiryPolicy(new Duration(TimeUnit.MILLISECONDS, 20));
 CreatedExpiryPolicy policy3 = new CreatedExpiryPolicy(new Duration(TimeUnit.MILLISECONDS, 10));
 assertEquals(policy, policy2);
 assertNotEquals(policy, policy3);
 assertEquals(policy.hashCode(), policy2.hashCode());
 assertNotEquals(policy.hashCode(), policy3.hashCode());
 MutableConfiguration<Integer, Integer> config = new MutableConfiguration<>();
 config.setExpiryPolicyFactory(FactoryBuilder.factoryOf(policy2)).setStatisticsEnabled(true);
 Cache<Integer, Integer> cache = cacheManager.createCache(getTestCacheName(), config);
 assertEquals(20, policy.getExpiryForCreation().getDurationAmount());
 assertNull(policy.getExpiryForAccess());
 assertNull(policy.getExpiryForUpdate());
}