Java EhCacheFactoryBean.getObject方法代码示例

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包/类
@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
EhCacheBasedAclCache aclCache() {
    EhCacheFactoryBean factoryBean = new EhCacheFactoryBean();
    EhCacheManagerFactoryBean cacheManager = new   EhCacheManagerFactoryBean();
    cacheManager.setAcceptExisting(true);
    cacheManager.setCacheManagerName(CacheManager.class.getName());
    cacheManager.afterPropertiesSet();

    factoryBean.setCacheName("aclCache");
    factoryBean.setCacheManager(cacheManager.getObject());
    //factoryBean.setMaxBytesLocalHeap("16M");
    //factoryBean.setMaxEntriesLocalHeap(0L);
    factoryBean.afterPropertiesSet();
    return new EhCacheBasedAclCache(factoryBean.getObject());
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Before
public void before() throws Exception {
    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheName("unittest");
    ehCacheFactoryBean.afterPropertiesSet();
    this.cache = (Cache) ehCacheFactoryBean.getObject();

    id = mock(PId.class);

    continuation = new TestContinuation<PiEntity>();

    when(dhtClientFactory.createReader()).thenReturn(dhtReader);
    when(dhtClientFactory.createWriter()).thenReturn(dhtWriter);

    dhtPiEntityReadAnswer = new GenericContinuationAnswer<PiEntity>(dhtPiEntity);
    doAnswer(dhtPiEntityReadAnswer).when(dhtReader).getAsync(eq(id), isA(Continuation.class));

    dhtPiEntityUpdateAnswer = new UpdateResolvingContinuationAnswer(dhtPiEntity);
    doAnswer(dhtPiEntityUpdateAnswer).when(dhtWriter).update(eq(id), (PiEntity) any(), isA(UpdateResolvingPiContinuation.class));

    when(updateResolvingContinuation.update(isA(PiEntity.class), isA(PiEntity.class))).thenReturn(dhtPiEntity);

    dhtCache = new DhtCache();
    dhtCache.setCache(this.cache);
    dhtCache.setDhtClientFactory(dhtClientFactory);
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入方法依赖的package包/类
public GoCache(EhCacheFactoryBean ehCacheFactoryBean, TransactionSynchronizationManager transactionSynchronizationManager) {
    this((Cache) ehCacheFactoryBean.getObject(), transactionSynchronizationManager);
}
 

import org.springframework.cache.ehcache.EhCacheFactoryBean; //导入方法依赖的package包/类
public void setUp(boolean isMockFile) throws Exception {
    if (isMockFile) {
        mockFile = mock(File.class);
        when(mockFile.exists()).thenReturn(true);
        when(mockFile.getFreeSpace()).thenReturn(1024 * 1024 * 1024L);
        systemResourceState = new SystemResourceState() {
            @Override
            protected File getFile(String instancePath) {
                return mockFile;
            }
        };
    } else
        systemResourceState = new SystemResourceState();

    libvirtManager = mock(LibvirtManager.class);
    systemResourceState.setLibvirtManager(libvirtManager);

    xenConfigurationParser = mock(XenConfigurationParser.class);
    systemResourceState.setXenConfigurationParser(xenConfigurationParser);

    mockNodeInfo = new NodeInfo();
    mockNodeInfo.cpus = 10;
    mockNodeInfo.memory = 2048 * 1024;

    domainInfo1 = new DomainInfo();
    domainInfo1.nrVirtCpu = 4;

    domainInfo2 = new DomainInfo();
    domainInfo2.nrVirtCpu = 2;

    mockDomain = mock(Domain.class);
    when(mockDomain.getInfo()).thenReturn(domainInfo1).thenReturn(domainInfo2);
    when(mockDomain.getMaxMemory()).thenReturn(768 * 1024L).thenReturn(256 * 1024L);

    setupLibvirtManagerExpectations(Arrays.asList(new Domain[] { mockDomain, mockDomain }));

    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheName("unittest");
    ehCacheFactoryBean.setTimeToIdle(cacheTTLSeconds);
    ehCacheFactoryBean.setTimeToLive(cacheTTLSeconds);
    ehCacheFactoryBean.afterPropertiesSet();
    this.cache = (Cache) ehCacheFactoryBean.getObject();

    systemResourceState.setCache(cache);
}