Java CacheConfiguration.setTimeToLiveSeconds方法代码示例

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
/**
 * Gets an EH Cache manager.
 *
 * @return the EH Cache manager.
 */
@Bean(destroyMethod = "shutdown")
public net.sf.ehcache.CacheManager ehCacheManager()
{
    CacheConfiguration cacheConfiguration = new CacheConfiguration();
    cacheConfiguration.setName(HERD_CACHE_NAME);
    cacheConfiguration.setTimeToLiveSeconds(configurationHelper.getProperty(ConfigurationValue.HERD_CACHE_TIME_TO_LIVE_SECONDS, Long.class));
    cacheConfiguration.setTimeToIdleSeconds(configurationHelper.getProperty(ConfigurationValue.HERD_CACHE_TIME_TO_IDLE_SECONDS, Long.class));
    cacheConfiguration.setMaxElementsInMemory(configurationHelper.getProperty(ConfigurationValue.HERD_CACHE_MAX_ELEMENTS_IN_MEMORY, Integer.class));
    cacheConfiguration.setMemoryStoreEvictionPolicy(configurationHelper.getProperty(ConfigurationValue.HERD_CACHE_MEMORY_STORE_EVICTION_POLICY));

    net.sf.ehcache.config.Configuration config = new net.sf.ehcache.config.Configuration();
    config.addCache(cacheConfiguration);

    return net.sf.ehcache.CacheManager.create(config);
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
private CacheManager getCacheManager() {
	if (manager == null) {
		Configuration config = new Configuration();
		CacheConfiguration cacheconfig = new CacheConfiguration(getName(), maxElementsInMemory);
		cacheconfig.setDiskExpiryThreadIntervalSeconds(diskExpiryThreadIntervalSeconds);
		cacheconfig.setDiskPersistent(diskPersistent);
		cacheconfig.setEternal(eternal);
		cacheconfig.setMaxElementsOnDisk(maxElementsOnDisk);
		cacheconfig.setMemoryStoreEvictionPolicyFromObject(memoryStoreEvictionPolicy);
		cacheconfig.setOverflowToDisk(overflowToDisk);
		cacheconfig.setTimeToIdleSeconds(timeToIdleSeconds);
		cacheconfig.setTimeToLiveSeconds(timeToLiveSeconds);

		DiskStoreConfiguration diskStoreConfigurationParameter = new DiskStoreConfiguration();
		diskStoreConfigurationParameter.setPath(getPath().getAbsolutePath());
		config.addDiskStore(diskStoreConfigurationParameter);
		config.setDefaultCacheConfiguration(cacheconfig);
		manager = new CacheManager(config);
	}
	return manager;
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
/**
 * Load cache.
 *
 * @param name the name
 * @return the cache configuration
 */
private CacheConfiguration loadCache(String name) {
	CacheConfiguration cacheConfiguration = new CacheConfiguration();
       cacheConfiguration.setMemoryStoreEvictionPolicy("LRU");
       cacheConfiguration.setMaxEntriesLocalHeap(10000);
       cacheConfiguration.setMaxEntriesLocalDisk(1000000);
       if (debug) {
       	cacheConfiguration.setTimeToIdleSeconds(1);
       	cacheConfiguration.setTimeToLiveSeconds(2);
	}
       else {
       	cacheConfiguration.setTimeToIdleSeconds(10);
       	cacheConfiguration.setTimeToLiveSeconds(20);
       }
       cacheConfiguration.setName(name);
       
       return cacheConfiguration;
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
@Override
protected Cache getMissingCache(final String name) {
    final Cache missingCache = super.getMissingCache(name);

    if (missingCache == null) {
        final CacheConfiguration cacheConfiguration = defaults.clone().name(name);

        final String cacheName = getCacheName(name);

        if (cacheExpires.containsKey(cacheName)) {
            cacheConfiguration.setTimeToLiveSeconds(cacheExpires.get(cacheName));
        }

        final net.sf.ehcache.Cache ehcache = new net.sf.ehcache.Cache(cacheConfiguration);
        ehcache.initialise();

        return new EhCacheCache(ehcache);
    } else {
        return missingCache;
    }
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
/**
 * Read cache config from the file caches.dat
 *
 * @param strCacheName
 *            The cache name
 * @return The config
 */
private CacheConfiguration getCacheConfiguration( String strCacheName )
{
    CacheConfiguration config = new CacheConfiguration( );
    config.setName( strCacheName );
    config.setMaxElementsInMemory( getIntProperty( strCacheName, PROPERTY_MAX_ELEMENTS, _nDefaultMaxElementsInMemory ) );
    config.setEternal( getBooleanProperty( strCacheName, PROPERTY_ETERNAL, _bDefaultEternal ) );
    config.setTimeToIdleSeconds( getLongProperty( strCacheName, PROPERTY_TIME_TO_IDLE, _lDefaultTimeToIdle ) );
    config.setTimeToLiveSeconds( getLongProperty( strCacheName, PROPERTY_TIME_TO_LIVE, _lDefaultTimeToLive ) );
    config.setOverflowToDisk( getBooleanProperty( strCacheName, PROPERTY_OVERFLOW_TO_DISK, _bDefaultOverflowToDisk ) );
    config.setDiskPersistent( getBooleanProperty( strCacheName, PROPERTY_DISK_PERSISTENT, _bDefaultDiskPersistent ) );
    config.setDiskExpiryThreadIntervalSeconds( getLongProperty( strCacheName, PROPERTY_DISK_EXPIRY, _lDefaultDiskExpiry ) );
    config.setMaxElementsOnDisk( getIntProperty( strCacheName, PROPERTY_MAX_ELEMENTS_DISK, _nDefaultMaxElementsOnDisk ) );
    config.setStatistics( getBooleanProperty( strCacheName, PROPERTY_STATISTICS, _bDefaultStatistics ) );

    return config;
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
public static Cache createMemCache(String name , long maxEntriesLocalHeap, long timeToLiveSeconds,
                                   long timeToIdleSeconds){
    CacheConfiguration config = new CacheConfiguration();
    config.setName(name);
    config.setEternal(false);
    config.setMaxEntriesLocalHeap(maxEntriesLocalHeap);
    config.setTimeToLiveSeconds(timeToLiveSeconds);
    config.setTimeToIdleSeconds(timeToIdleSeconds);
    config.setCopyOnRead(false);
    config.setCopyOnWrite(true);
    config.setMemoryStoreEvictionPolicy("LRU");

    CopyStrategyConfiguration copyConfig = new CopyStrategyConfiguration();
    copyConfig.setClass("org.cam.core.cache.CloneCopyStrategy");
    config.addCopyStrategy(copyConfig);

    PersistenceConfiguration persistConfig = new PersistenceConfiguration();
    persistConfig.setStrategy("NONE");
    config.addPersistence(persistConfig);

    return new Cache(config);
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
public void add(Query query) {
    String name = query.getQid().getId();
    if (!this.manager.cacheExists(name) && query.isCacheable()) {
        
        CacheConfiguration config = defaultConfig.clone();
        config.setName(name);
        config.setEternal(query.isEternal());
        config.setTimeToLiveSeconds(query.getCacheTime());
        
        Cache c = new Cache(config);
        this.manager.addCache(c);
        
        if (log.isDebugEnabled()) {
            log.debug(String.format("Cache %s created: eternal = %s, cacheTime = %d", 
                    c.getName(), query.isEternal(), query.getCacheTime()));
        }
        
    }
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
private void configureCache() {

        CacheManager singletonManager;
        try {
            InputStream inputStream = this.getClass().getResourceAsStream("/ehcache.xml");
            singletonManager = CacheManager.newInstance(inputStream);
        } catch (Exception e) {
            singletonManager = CacheManager.create();
            singletonManager.addCache(CACHE_NAME);
            cache.getCacheConfiguration();
            cache = singletonManager.getCache(CACHE_NAME);
            CacheConfiguration cacheConfiguration = cache.getCacheConfiguration();
            cacheConfiguration.setTimeToIdleSeconds(300);
            cacheConfiguration.setTimeToLiveSeconds(300);
            e.printStackTrace();

        }
        cache = singletonManager.getCache(CACHE_NAME);

    }
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
protected CacheConfiguration createCacheConfiguration(int _maxElements) {
  MemoryStoreEvictionPolicy _policy = MemoryStoreEvictionPolicy.LRU;
  switch (algorithm) {
    case CLOCK: _policy = MemoryStoreEvictionPolicy.CLOCK; break;
  }
  CacheConfiguration c = new CacheConfiguration(CACHE_NAME, _maxElements)
    .memoryStoreEvictionPolicy(_policy)
    .eternal(true)
    .diskExpiryThreadIntervalSeconds(0)
    .persistence(new PersistenceConfiguration().strategy(PersistenceConfiguration.Strategy.NONE));
  if (withExpiry) {
    c.setEternal(false);
    c.setTimeToLiveSeconds(5 * 60);
  }
  return c;
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
@Test
public void testCacheExpiration() throws Exception {
  Ehcache cache = CacheManager.getInstance().getEhcache("org.firepick.firebom.part.Part");
  CacheConfiguration configuration = cache.getCacheConfiguration();
  long idleTime = configuration.getTimeToIdleSeconds();
  long liveTime = configuration.getTimeToLiveSeconds();
  configuration.setTimeToIdleSeconds(1);
  configuration.setTimeToLiveSeconds(1);
  URL url = new URL("http://www.mcmaster.com/#91290A115");
  Part part1 = PartFactory.getInstance().createPart(url);
  Part part2 = PartFactory.getInstance().createPart(url);
  assertEquals(part1, part2);

  Thread.sleep(2000);

  Part part3 = PartFactory.getInstance().createPart(url);
  assert (part1 != part3);
  configuration.setTimeToIdleSeconds(idleTime);
  configuration.setTimeToLiveSeconds(liveTime);
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
protected void createCache(String name, int expirationTime) {
		synchronized (this.getClass()) {
			cacheManager.addCache(name);

			Ehcache cache = cacheManager.getEhcache(name);
			CacheConfiguration config = cache.getCacheConfiguration();
			config.setEternal(false);
			config.setTimeToLiveSeconds(expirationTime);
//		    config.setTimeToIdleSeconds(60);
//		    config.setMaxElementsInMemory(10000);
//		    config.setMaxElementsOnDisk(1000000);
		    
			BlockingCache blockingCache = new BlockingCache(cache);
			cacheManager.replaceCacheWithDecoratedCache(cache, blockingCache);
		}
	}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
@Override
public Ticket getTicket(final String ticketIdToGet) {
    final String ticketId = encodeTicketId(ticketIdToGet);
    if (ticketId == null) {
        return null;
    }

    final Element element = this.ehcacheTicketsCache.get(ticketId);
    if (element == null) {
        LOGGER.debug("No ticket by id [{}] is found in the registry", ticketId);
        return null;
    }
    final Ticket ticket = decodeTicket((Ticket) element.getObjectValue());

    final CacheConfiguration config = new CacheConfiguration();
    config.setTimeToIdleSeconds(ticket.getExpirationPolicy().getTimeToIdle());
    config.setTimeToLiveSeconds(ticket.getExpirationPolicy().getTimeToLive());
    
    if (element.isExpired(config) || ticket.isExpired()) {
        LOGGER.debug("Ticket [{}] has expired", ticket.getId());
        this.ehcacheTicketsCache.evictExpiredElements();
        this.ehcacheTicketsCache.flush();
        return null;
    }
    
    return ticket;
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
@Override
public void afterPropertiesSet() throws Exception {
    Cache.ID = key + "." + Dates.newDateStringOfFormatDateTimeSSSNoneSpace();
    Cache.HOST = Utils.getLocalHostIP();
    Cache.CACHE_STORE = key + spliter + "cache" + spliter + "store";
    Cache.CACHE_STORE_SYNC = Cache.CACHE_STORE + spliter + "sync";
    if (this.localEnabled) {
        Configuration configuration = new Configuration();
        configuration.setName(Cache.ID);
        configuration.setMaxBytesLocalHeap(localMaxBytesLocalHeap);
        configuration.setMaxBytesLocalDisk(localMaxBytesLocalDisk);
        // DiskStore
        // 每次启动设置新的文件地址,以避免重启期间一级缓存未同步,以及单机多应用启动造成EhcacheManager重复的问题.
        DiskStoreConfiguration dsc = new DiskStoreConfiguration();
        dsc.setPath(localStoreLocation + Cache.ID);
        configuration.diskStore(dsc);
        // DefaultCache
        CacheConfiguration defaultCacheConfiguration = new CacheConfiguration();
        defaultCacheConfiguration.setEternal(false);
        defaultCacheConfiguration.setOverflowToDisk(true);
        defaultCacheConfiguration.setDiskPersistent(false);
        defaultCacheConfiguration.memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU);
        defaultCacheConfiguration.setDiskExpiryThreadIntervalSeconds(localDiskExpiryThreadIntervalSeconds);
        // 默认false,使用引用.设置为true,避免外部代码修改了缓存对象.造成EhCache的缓存对象也随之改变
        // 但是设置为true后,将引起element的tti不自动刷新.如果直接新建element去覆盖原值.则本地ttl和远程ttl会产生一定的误差.
        // 因此,使用时放弃手动覆盖方式刷新本地tti,当本地tti过期后,自动从Redis中再获取即可.
        defaultCacheConfiguration.copyOnRead(true);
        defaultCacheConfiguration.copyOnWrite(true);
        defaultCacheConfiguration.setTimeToIdleSeconds(localTimeToIdleSeconds);
        defaultCacheConfiguration.setTimeToLiveSeconds(localTimeToLiveSeconds);
        configuration.setDefaultCacheConfiguration(defaultCacheConfiguration);
        configuration.setDynamicConfig(false);
        configuration.setUpdateCheck(false);
        this.cacheManager = new CacheManager(configuration);
        this.cacheSync = new RedisPubSubSync(this);// 使用Redis Topic发送订阅缓存变更消息
    }
}
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
/**
	 * Eh cache manager.
	 *
	 * @return the net.sf.ehcache. cache manager
	 */
	@SuppressWarnings("deprecation")
	@Bean(destroyMethod="shutdown")
    public net.sf.ehcache.CacheManager ehCacheManager() {
        CacheConfiguration cacheConfiguration = new CacheConfiguration();
        cacheConfiguration.setMemoryStoreEvictionPolicy("LRU");
        cacheConfiguration.setMaxEntriesLocalHeap(1000);
        cacheConfiguration.setEternal(false);
        cacheConfiguration.setOverflowToDisk(true);
        cacheConfiguration.setMaxElementsInMemory(1000);
        cacheConfiguration.setMaxElementsOnDisk(10000);
//        cacheConfiguration.setDiskPersistent(false);
//        cacheConfiguration.setStatistics(false);
        cacheConfiguration.setTimeToIdleSeconds(300);
        cacheConfiguration.setTimeToLiveSeconds(600);

        net.sf.ehcache.config.Configuration config = new net.sf.ehcache.config.Configuration();
        DiskStoreConfiguration diskStoreConfiguration = new DiskStoreConfiguration();
        diskStoreConfiguration.setPath(System.getProperty("java.io.tmpdir"));
        config.diskStore(diskStoreConfiguration);
        config.setDynamicConfig(true);
        config.setMonitoring("autodetect");
        config.setUpdateCheck(false);
        config.defaultCache(cacheConfiguration);
        
    	CacheSettings.Items.list.parallelStream().forEach(it -> {
    		config.addCache(loadCache(it));
    	});

        return net.sf.ehcache.CacheManager.newInstance(config);
    }
 

import net.sf.ehcache.config.CacheConfiguration; //导入方法依赖的package包/类
public BlockingCacheFactory(int timeToLiveSeconds, int maxEntriesLocalHeap) {
    Configuration cfg = new Configuration();
    CacheConfiguration.CacheDecoratorFactoryConfiguration cdfc =
            new CacheConfiguration.CacheDecoratorFactoryConfiguration();
    cdfc.setClass(BlockingCacheDecoratorFactory.class.getName());
    CacheConfiguration defaultCacheCfg = new CacheConfiguration();
    defaultCacheCfg.addCacheDecoratorFactory(cdfc);
    defaultCacheCfg.setTimeToLiveSeconds(timeToLiveSeconds);
    defaultCacheCfg.setMaxEntriesLocalHeap(maxEntriesLocalHeap);
    cfg.addDefaultCache(defaultCacheCfg);

    manager = CacheManager.create(cfg);

}