Java Duration類代碼示例

import javax.cache.expiry.Duration; //導入依賴的package包/類
@Override
public void addTicket(final Ticket ticketToAdd) {
    final Ticket ticket = encodeTicket(ticketToAdd);
    LOGGER.debug("Adding ticket [{}] to the cache [{}]", ticket.getId(), this.ticketIgniteCache.getName());
    this.ticketIgniteCache.withExpiryPolicy(new ExpiryPolicy() {
        @Override
        public Duration getExpiryForCreation() {
            return new Duration(TimeUnit.SECONDS, ticket.getExpirationPolicy().getTimeToLive());
        }

        @Override
        public Duration getExpiryForAccess() {
            final long idleTime = ticket.getExpirationPolicy().getTimeToIdle() <= 0
                    ? ticket.getExpirationPolicy().getTimeToLive()
                    : ticket.getExpirationPolicy().getTimeToIdle();
            return new Duration(TimeUnit.SECONDS, idleTime);
        }

        @Override
        public Duration getExpiryForUpdate() {
            return new Duration(TimeUnit.SECONDS, ticket.getExpirationPolicy().getTimeToLive());
        }
    }).put(ticket.getId(), ticket);
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
@Override
public void configure(Binder binder) {

    //programmatically configured cache
    Configuration<String, String> programmaticCache =
            new MutableConfiguration<String, String>()
                    .setTypes(String.class, String.class)
                    .setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(Duration.ONE_HOUR))
                    .setReadThrough(true)
                    .setWriteThrough(true)
                    .addCacheEntryListenerConfiguration(new MyCache2EntryListenerConfiguration());

    //contribute the cache into BQ
    JCacheModule.extend(binder).setConfiguration("myCache2", programmaticCache);

    BQCoreModule.extend(binder).addCommand(DemoHazelcastCommand.class);
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/**
 * Create a new cache from the given cache manager.
 *
 * @param cacheName         Name of the cache.
 * @param keyClass          Type of the key class.
 * @param valueClass        Type of the value class.
 * @param defaultExpiryTime Cache expire time in minutes.
 * @param cacheConfigMap    Cache config map.
 * @param cacheManager      Cache manager to use to create the cache.
 * @param <K>               Type of the Key.
 * @param <V>               Type of the Value.
 * @return Created cache.
 */
public static <K, V> Cache<K, V> createCache(String cacheName, Class<K> keyClass, Class<V> valueClass,
                                             int defaultExpiryTime, Map<String, CacheConfig> cacheConfigMap,
                                             CacheManager cacheManager) {

    Duration cacheExpiry = new Duration(TimeUnit.MINUTES, getExpireTime(cacheConfigMap, cacheName,
            defaultExpiryTime));

    boolean isStatisticsEnabled = false;

    if (cacheConfigMap.get(cacheName) != null) {
        isStatisticsEnabled = cacheConfigMap.get(cacheName).isStatisticsEnabled();
    }

    MutableConfiguration<K, V> configuration = new MutableConfiguration<>();
    configuration.setStoreByValue(false)
            .setTypes(keyClass, valueClass)
            .setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(cacheExpiry))
            .setStatisticsEnabled(isStatisticsEnabled);

    return cacheManager.createCache(cacheName, configuration);
}
 

import javax.cache.expiry.Duration; //導入依賴的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.Duration; //導入依賴的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.expiry.Duration; //導入依賴的package包/類
public static void main(String[] args) throws InterruptedException {

		try (Ignite ignite = Ignition.start("config/default-config.xml")) {

			CacheConfiguration<String, LocalDateTime> cacheCfg = new CacheConfiguration<>("CacheQueriesScanQueryExample");
			cacheCfg.setCacheMode(CacheMode.PARTITIONED).setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.HOURS, 3)));

			try (IgniteCache<String, LocalDateTime> igniteCache = ignite.getOrCreateCache(cacheCfg)) {

				LocalDateTime now = LocalDateTime.now();

				igniteCache.put("doctor", now);
				igniteCache.put("doctor who", now.plusHours(10L));
				igniteCache.put("doctor who", now.minusYears(1L));

				System.out.println("--------ScanQuery----------");
				try (QueryCursor<Entry<Object, Object>> query = igniteCache.query(new ScanQuery<>((k, v) -> v.equals(now)))) {
					for (Entry<Object, Object> entry : query) {
						System.out.println(entry.getKey() + ":" + entry.getValue());
					}
				}
			}
		}
	}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
@BeforeClass
public static void before() throws Exception {
    dataModel = Converters.toDataModel(new XSSFWorkbook(pathDataModel));
    
    CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();

    MutableConfiguration config = new MutableConfiguration();
    config.setStoreByValue(false)
          .setExpiryPolicyFactory(AccessedExpiryPolicy.factoryOf(Duration.ETERNAL))
          .setStatisticsEnabled(false);

    cacheManager.createCache(CacheBasedDataSetAccessor.DATA_SET_TO_ID_CACHE_NAME, config.setTypes(IDataModelId.class, IDataSet.class));
    cacheManager.createCache(CacheBasedDataSetAccessor.DATA_SET_TO_NAME_CACHE_NAME, config.setTypes(String.class, IDataSet.class));
    
    ExternalServices.INSTANCE.setDataSetAccessor(new CacheBasedDataSetAccessor());

    expectedValues = new HashMap<>();
    
    SpreadsheetEvaluator evaluator = new SpreadsheetEvaluator(dataModel);
    for (int i = expectedRowStart; i <= expectedRowEnd; i++) {
        ICellValue value = evaluator.evaluate(A1Address.fromA1Address(expectedColumn + i)).getResult();
        expectedValues.put(expectedColumn + i, value.get());
    }
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/**
 * @param duration Duration.
 * @return TTL.
 */
public static long toTtl(Duration duration) {
    if (duration == null)
        return TTL_NOT_CHANGED;

    if (duration.getDurationAmount() == 0) {
        if (duration.isEternal())
            return TTL_ETERNAL;

        assert duration.isZero();

        return TTL_ZERO;
    }

    assert duration.getTimeUnit() != null : duration;

    return duration.getTimeUnit().toMillis(duration.getDurationAmount());
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/** {@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;
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/** {@inheritDoc} */
@Override public void run() {
    try {
        barrier.await();

        ExpiryPolicy plc1 = new CreatedExpiryPolicy(new Duration(MILLISECONDS, expirationDuration));

        int keyStart = keysRangeGenerator.getAndIncrement() * cnt;

        for (int i = keyStart; i < keyStart + cnt; i++)
            cache.withExpiryPolicy(plc1).put("key" + i, 1);

        barrier.await();
    }
    catch (Exception e) {
        throw new IgniteException(e);
    }
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/** {@inheritDoc} */
@Override public ExpiryPolicy create() {
    return new ExpiryPolicy() {
        @Override public Duration getExpiryForCreation() {
            return new Duration(TimeUnit.MILLISECONDS, 500);
        }

        @Override public Duration getExpiryForAccess() {
            return new Duration(TimeUnit.MILLISECONDS, 600);
        }

        @Override public Duration getExpiryForUpdate() {
            return new Duration(TimeUnit.MILLISECONDS, 700);
        }
    };
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/**
 * @throws Exception If failed.
 */
public void testEvict() throws Exception {
    Ignite ignite1 = startGrid(1);

    IgniteCache<Object, Object> cache = ignite1.cache(DEFAULT_CACHE_NAME).withExpiryPolicy(new CreatedExpiryPolicy(
        new Duration(TimeUnit.MILLISECONDS, 100L)));

    // Putting entry.
    for (int i = 0; i < KEYS; i++)
        cache.put(i, i);

    // Wait when entry
    U.sleep(200);

    // Check that entry is evicted from cache, but local store does contain it.
    for (int i = 0; i < KEYS; i++) {
        cache.localEvict(Arrays.asList(i));

        assertNull(cache.localPeek(i));

        assertEquals(i, (int)LOCAL_STORE_1.load(i).get1());

        assertEquals(i, cache.get(i));
    }
}
 

import javax.cache.expiry.Duration; //導入依賴的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.Duration; //導入依賴的package包/類
/** {@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;
}
 

import javax.cache.expiry.Duration; //導入依賴的package包/類
/** {@inheritDoc} */
@Override public ExpiryPolicy create() {
    return new ExpiryPolicy() {
        @Override public Duration getExpiryForCreation() {
            return new Duration(TimeUnit.MILLISECONDS, TIMEOUT);
        }

        /** {@inheritDoc} */
        @Override public Duration getExpiryForAccess() {
            return new Duration(TimeUnit.MILLISECONDS, TIMEOUT);
        }

        /** {@inheritDoc} */
        @Override public Duration getExpiryForUpdate() {
            return new Duration(TimeUnit.MILLISECONDS, TIMEOUT);
        }
    };
}