import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的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.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/**
 * @param atomicityMode Atomicity mode.
 * @param heapCache Heap cache flag.
 * @param expiryPlc Expiry policy flag.
 * @return Cache configuration.
 */
private CacheConfiguration cacheConfiguration(CacheAtomicityMode atomicityMode,
    boolean heapCache,
    boolean expiryPlc) {
    CacheConfiguration ccfg = new CacheConfiguration();

    ccfg.setAtomicityMode(atomicityMode);
    ccfg.setOnheapCacheEnabled(heapCache);
    ccfg.setWriteSynchronizationMode(FULL_SYNC);
    ccfg.setName("testCache");

    if (expiryPlc)
        ccfg.setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(Duration.FIVE_MINUTES));

    return ccfg;
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/** */
@Before
public void createCaches() {
    CacheConfiguration configuration = new CacheConfiguration<>();
    ModifiedExpiryPolicy expiryPolicy = new ModifiedExpiryPolicy(new Duration(TimeUnit.MILLISECONDS, 100));
    configuration.setExpiryPolicyFactory(FactoryBuilder.factoryOf(expiryPolicy));

    createCache(firstCache, TRANSACTIONAL, PARTITIONED, false, 0, configuration);
    createCache(secondCache, TRANSACTIONAL, PARTITIONED, false, 0, configuration);
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
private void validateConfiguration(CompleteConfiguration<?, ?> configuration)
{
    if (configuration.isStoreByValue())
    {
        throw new UnsupportedOperationException("Store by value is not supported in Guava!");
    }

    if (configuration.getExpiryPolicyFactory() == null)
    {
        throw new NullPointerException("Expiry policy factory cannot be null!");
    }

    ExpiryPolicy expiryPolicy = configuration.getExpiryPolicyFactory().create();

    if (!(expiryPolicy instanceof EternalExpiryPolicy)
        && !(expiryPolicy instanceof ModifiedExpiryPolicy)
        && !(expiryPolicy instanceof TouchedExpiryPolicy))
    {
        throw new UnsupportedOperationException("Invalid expiry policy configuration!");
    }

    if (configuration.isReadThrough() && configuration.getCacheLoaderFactory() == null)
    {
        throw new IllegalArgumentException("Invalid read through cache configuration!");
    }

    if (configuration.isWriteThrough() || configuration.getCacheWriterFactory() != null)
    {
        throw new UnsupportedOperationException("Invalid write through cache configuration!");
    }
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
@Override
protected void setup(Settings settings, CacheManager cacheManager) {

    // example items cache
    cacheManager.createCache(ITEMS_CACHE, new MutableConfiguration()
            .setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(Duration.ONE_MINUTE))
            .setStatisticsEnabled(true)
            .setStoreByValue(true));
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
@Override
protected void setup(Settings settings, CacheManager cacheManager) {

    // example items cache
    cacheManager.createCache(ITEMS_CACHE, new MutableConfiguration()
            .setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(Duration.ONE_MINUTE))
            .setStatisticsEnabled(true)
            .setStoreByValue(true));

    // example employee cache
    cacheManager.createCache(EMPLOYEE_CACHE, new MutableConfiguration()
            .setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(Duration.ONE_MINUTE))
            .setStatisticsEnabled(true)
            .setStoreByValue(true));
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/**
 * @param maxInactiveInteval Interval to use in expiry policy.
 * @param cache Cache.
 * @param <T> Cached object type.
 * @return Cache with expiry policy if {@code maxInactiveInteval} greater than zero.
 */
private <T> IgniteCache<String, T> cacheWithExpiryPolicy(final int maxInactiveInteval,
    final IgniteCache<String, T> cache) {
    if (maxInactiveInteval > 0) {
        long ttl = maxInactiveInteval * 1000L;

        ExpiryPolicy plc = new ModifiedExpiryPolicy(new Duration(MILLISECONDS, ttl));

        return cache.withExpiryPolicy(plc);
    }

    return cache;
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> applyx(IgniteInternalCache<Object, Object> c, GridKernalContext ctx) {
    if (ttl != null && ttl > 0) {
        Duration duration = new Duration(MILLISECONDS, ttl);

        c = c.withExpiryPolicy(new ModifiedExpiryPolicy(duration));
    }

    return c.putIfAbsentAsync(key, val);
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/**
 * @param ccfg Cache configuration.
 * @throws Exception If failed.
 */
private void checkExpiredEvents(CacheConfiguration<Object, Object> ccfg) throws Exception {
    IgniteCache<Object, Object> cache = ignite(0).createCache(ccfg);

    try {
        evtCntr = new AtomicInteger();

        CacheEntryListenerConfiguration<Object, Object> lsnrCfg = new MutableCacheEntryListenerConfiguration<>(
            new ExpiredListenerFactory(),
            null,
            true,
            false
        );

        cache.registerCacheEntryListener(lsnrCfg);

        IgniteCache<Object, Object> expiryCache =
            cache.withExpiryPolicy(new ModifiedExpiryPolicy(new Duration(MILLISECONDS, 500)));

        expiryCache.put(1, 1);

        for (int i = 0; i < 10; i++)
            cache.get(i);

        boolean wait = GridTestUtils.waitForCondition(new GridAbsPredicate() {
            @Override public boolean apply() {
                return evtCntr.get() > 0;
            }
        }, 5000);

        assertTrue(wait);

        U.sleep(100);

        assertEquals(1, evtCntr.get());
    }
    finally {
        ignite(0).destroyCache(cache.getName());
    }
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public Object call() throws Exception {
    IgniteCache cache = ignite.cache(cacheName);

    if (withExpiryPlc)
        cache = cache.withExpiryPolicy(ModifiedExpiryPolicy.factoryOf(Duration.FIVE_MINUTES).create());

    Map vals = cache.getAll(keys);

    Collection<CacheEntry> entries = cache.getEntries(keys);

    assertEquals(vals.size(), entries.size());

    for (CacheEntry entry : entries) {
        Object val = vals.get(entry.getKey());

        assertEquals(val, entry.getValue());
    }

    return vals;
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
@Override public Factory<? extends ExpiryPolicy> createFactory( Long seconds ) {
  return ModifiedExpiryPolicy.factoryOf( getDuration( seconds ) );
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
@Test
public void expire_whenCreated_ModifiedExpiryPolicy() {
  // since TouchedExpiryPolicy uses same duration for created and accessed, this policy will work same as
  // CreatedExpiryPolicy for this test.
  expire_whenCreated(FactoryBuilder.factoryOf(new ModifiedExpiryPolicy(Duration.ZERO)));
}
 

import javax.cache.expiry.ModifiedExpiryPolicy; //导入依赖的package包/类
/**
 * @throws Exception if failed.
 */
public void testCreateUpdate0() throws Exception {
    startGrids(1);

    long ttl = 60L;

    final String key = "key1";

    final IgniteCache<String, String> cache = jcache();

    for (int i = 0; i < 1000; i++) {
        final IgniteCache<String, String> cache0 = cache.withExpiryPolicy(new ModifiedExpiryPolicy(new Duration(TimeUnit.HOURS, ttl)));

        cache0.put(key, key);

        info("PUT DONE");
    }

    long pSize = grid(0).context().cache().internalCache(DEFAULT_CACHE_NAME).context().ttl().pendingSize();

    assertTrue("Too many pending entries: " + pSize, pSize <= 1);

    cache.remove(key);

    pSize = grid(0).context().cache().internalCache(DEFAULT_CACHE_NAME).context().ttl().pendingSize();

    assertEquals(0, pSize);
}