Java EhCacheFactoryBean类代码示例

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    this.blockingDhtCache = new BlockingDhtCache();

    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheName("unittest");
    ehCacheFactoryBean.afterPropertiesSet();
    this.cache = (Cache) ehCacheFactoryBean.getObject();
    this.blockingDhtCache.setCache(this.cache);
    this.dhtClientFactory = mock(DhtClientFactory.class);
    this.blockingDhtCache.setDhtClientFactory(this.dhtClientFactory);
    this.id = mock(PId.class);
    when(this.id.toStringFull()).thenReturn("" + System.currentTimeMillis());
    this.piEntity = mock(PiEntity.class);
    this.blockingReader = mock(BlockingDhtReader.class);
    when(this.dhtClientFactory.createBlockingReader()).thenReturn(this.blockingReader);
    this.blockingWriter = mock(BlockingDhtWriter.class);
    when(this.dhtClientFactory.createBlockingWriter()).thenReturn(this.blockingWriter);
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Ignore("because this is just testing ehcache which hopefully works anyhow")
@Test
public void testThatCacheDoesExpire() throws Exception {
    // setup
    int ttl = 2;
    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheName("unittest1");
    ehCacheFactoryBean.setTimeToIdle(ttl);
    ehCacheFactoryBean.setTimeToLive(ttl);
    ehCacheFactoryBean.afterPropertiesSet();
    this.cache = (Cache) ehCacheFactoryBean.getObject();
    this.blockingDhtCache.setCache(this.cache);

    when(this.blockingReader.get(id)).thenReturn(piEntity);

    // act
    PiEntity result = this.blockingDhtCache.get(id);
    assertEquals(this.piEntity, result);
    Thread.sleep(ttl * 2 * 1000);

    result = this.blockingDhtCache.get(id);
    assertEquals(this.piEntity, result);

    // assert
    verify(this.blockingReader, times(2)).get(id);
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Lazy
@Autowired
@Bean
public EhCacheFactoryBean ehcacheTicketsCache(@Qualifier("cacheManager") final CacheManager manager) {
    final EhcacheProperties ehcacheProperties = casProperties.getTicket().getRegistry().getEhcache();
    final EhCacheFactoryBean bean = new EhCacheFactoryBean();
    bean.setCacheName(ehcacheProperties.getCacheName());
    bean.setCacheEventListeners(Collections.singleton(ticketRMISynchronousCacheReplicator()));
    bean.setTimeToIdle(ehcacheProperties.getCacheTimeToIdle());
    bean.setTimeToLive(ehcacheProperties.getCacheTimeToLive());

    bean.setCacheManager(manager);
    bean.setBootstrapCacheLoader(ticketCacheBootstrapCacheLoader());
    bean.setDiskExpiryThreadIntervalSeconds(ehcacheProperties.getDiskExpiryThreadIntervalSeconds());

    bean.setEternal(ehcacheProperties.isEternal());
    bean.setMaxEntriesLocalHeap(ehcacheProperties.getMaxElementsInMemory());
    bean.setMaxEntriesInCache(ehcacheProperties.getMaxElementsInCache());
    bean.setMaxEntriesLocalDisk(ehcacheProperties.getMaxElementsOnDisk());
    bean.setMemoryStoreEvictionPolicy(ehcacheProperties.getMemoryStoreEvictionPolicy());

    final PersistenceConfiguration c = new PersistenceConfiguration();
    c.strategy(ehcacheProperties.getPersistence());
    c.setSynchronousWrites(ehcacheProperties.isSynchronousWrites());
    bean.persistence(c);

    return bean;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public Ehcache ehcache(){
    EhCacheFactoryBean cacheFactoryBean = new EhCacheFactoryBean();
    cacheFactoryBean.setCacheManager(cacheManager());
    cacheFactoryBean.setCacheName("aclCache");
    cacheFactoryBean.setMaxBytesLocalHeap("1M");
    cacheFactoryBean.setMaxEntriesLocalHeap(0L);
    cacheFactoryBean.afterPropertiesSet();
    return cacheFactoryBean.getObject();
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean clusterEhcache() {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("clusterCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean alarmEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("alarmCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean commandTagEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("commandCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean deviceEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("deviceCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean processEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("processCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean deviceClassEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("deviceClassCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean dataTagEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("tagCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean ruleTagEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("ruleCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean controlTagEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("controlCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean equipmentEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("equipmentCache");
  factory.setCacheManager(cacheManager);
  return factory;
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入依赖的package包/类
@Bean
public EhCacheFactoryBean subEquipmentEhcache(CacheManager cacheManager) {
  EhCacheFactoryBean factory = new EhCacheFactoryBean();
  factory.setCacheName("subEquipmentCache");
  factory.setCacheManager(cacheManager);
  return factory;
}