Java PersistentCacheManager.getCache方法代码示例

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testStatefulSerializerWithDiskStateRepositoryDifferentPersistenceServices() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> cmBuilder = newCacheManagerBuilder().with(persistence(temporaryFolder.newFolder()
      .getAbsolutePath()))
      .withCache("myCache", newCacheConfigurationBuilder(Long.class, Person.class, heap(10).disk(50, MemoryUnit.MB, true))
          .withValueSerializer((Class) CompactJavaSerializer.class));
  PersistentCacheManager cacheManager = cmBuilder.build(true);

  Cache<Long, Person> myCache = cacheManager.getCache("myCache", Long.class, Person.class);

  myCache.put(42L, new Person("John", 42));
  myCache.put(35L, new Person("Marie", 35));

  cacheManager.close();

  cacheManager = cmBuilder.build(true);

  myCache = cacheManager.getCache("myCache", Long.class, Person.class);

  assertThat(myCache.get(42L).getName(), is("John"));
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void test3TiersStoreStatsAvailableInContextManager() throws Exception {
  PersistentCacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
      .with(new CacheManagerPersistenceConfiguration(new File(getStoragePath(), "StoreStatisticsTest")))
      .withCache("threeTieredCache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              newResourcePoolsBuilder()
                  .heap(1, MemoryUnit.MB)
                  .offheap(2, MemoryUnit.MB)
                  .disk(5, MemoryUnit.MB)
              )
      ).build(true);

  Cache<Long, String> cache = cacheManager.getCache("threeTieredCache", Long.class, String.class);

  assertNull(cache.get(0L));

  long onHeapMisses = StoreStatisticsTest.<CachingTierOperationOutcomes.GetOrComputeIfAbsentOutcome>findStat(cache, "getOrComputeIfAbsent", "OnHeap").count(CachingTierOperationOutcomes.GetOrComputeIfAbsentOutcome.MISS);
  assertThat(onHeapMisses, equalTo(1L));
  long offHeapMisses = StoreStatisticsTest.<LowerCachingTierOperationsOutcome.GetAndRemoveOutcome>findStat(cache, "getAndRemove", "OffHeap").count(LowerCachingTierOperationsOutcome.GetAndRemoveOutcome.MISS);
  assertThat(offHeapMisses, equalTo(1L));
  long diskMisses = StoreStatisticsTest.<AuthoritativeTierOperationOutcomes.GetAndFaultOutcome>findStat(cache, "getAndFault", "Disk").count(AuthoritativeTierOperationOutcomes.GetAndFaultOutcome.MISS);
  assertThat(diskMisses, equalTo(1L));

  cacheManager.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void threeTiersCacheManager() throws Exception {
  // tag::threeTiersCacheManager[]
  PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
      .with(CacheManagerBuilder.persistence(new File(getStoragePath(), "myData"))) // <1>
      .withCache("threeTieredCache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .heap(10, EntryUnit.ENTRIES) // <2>
                  .offheap(1, MemoryUnit.MB) // <3>
                  .disk(20, MemoryUnit.MB, true) // <4>
              )
      ).build(true);

  Cache<Long, String> threeTieredCache = persistentCacheManager.getCache("threeTieredCache", Long.class, String.class);
  threeTieredCache.put(1L, "stillAvailableAfterRestart"); // <5>

  persistentCacheManager.close();
  // end::threeTiersCacheManager[]
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testClusteredCacheSingleClient() throws Exception {

  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      newCacheManagerBuilder()
          .with(cluster(CLUSTER_URI).autoCreate())
          .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));
  final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true);

  final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class);

  cache.put(1L, "value");
  assertThat(cache.get(1L), is("value"));

  cacheManager.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testTieredClusteredCache() throws Exception {
  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      newCacheManagerBuilder()
          .with(cluster(CLUSTER_URI).autoCreate())
          .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class,
                  heap(2)
                  .with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));
  final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true);

  final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class);

  cache.put(1L, "value");
  assertThat(cache.get(1L), is("value"));

  cacheManager.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testClusteredCacheWithSerializableValue() throws Exception {
  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      newCacheManagerBuilder().with(cluster(CLUSTER_URI).autoCreate())
          .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, Person.class,
                  newResourcePoolsBuilder().with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true);

  Cache<Long, Person> cache = cacheManager.getCache("clustered-cache", Long.class, Person.class);

  cache.put(38L, new Person("Clustered Joe", 28));

  cacheManager.close();

  cacheManager = clusteredCacheManagerBuilder.build(true);
  cache = cacheManager.getCache("clustered-cache", Long.class, Person.class);

  assertThat(cache.get(38L).name, is("Clustered Joe"));
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testCloseCacheManagerSingleClient() {
  CacheManagerBuilder<PersistentCacheManager> cacheManagerBuilder = clusteredCacheManagerBuilder
      .withCache("test", newCacheConfigurationBuilder(Long.class, String.class,
          ResourcePoolsBuilder.newResourcePoolsBuilder()
              .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));

  PersistentCacheManager persistentCacheManager1 = cacheManagerBuilder.build(true);

  persistentCacheManager1.close();

  persistentCacheManager1.init();

  Cache<Long, String> cache = persistentCacheManager1.getCache("test", Long.class, String.class);
  cache.put(1L, "One");

  assertThat(cache.get(1L), is("One"));

  persistentCacheManager1.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testGetExpiredTwoClients() {

  TestTimeSource timeSource = new TestTimeSource();
  TimeSourceConfiguration timeSourceConfiguration = new TimeSourceConfiguration(timeSource);

  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      commonClusteredCacheManagerBuilder.using(timeSourceConfiguration);

  final PersistentCacheManager cacheManager1 = clusteredCacheManagerBuilder.build(true);
  final PersistentCacheManager cacheManager2 = clusteredCacheManagerBuilder.build(true);

  final Cache<Long, String> cache1 = cacheManager1.getCache("clustered-cache", Long.class, String.class);
  final Cache<Long, String> cache2 = cacheManager2.getCache("clustered-cache", Long.class, String.class);

  assertThat(cache2.get(1L), nullValue());
  cache1.put(1L, "value1");
  assertThat(cache1.get(1L), is("value1"));
  timeSource.advanceTime(1L);

  assertThat(cache2.get(1L), nullValue());
  assertThat(cache1.get(1L), nullValue());

  cacheManager2.close();
  cacheManager1.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testTerminationThenContainsKey() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(cluster.getConnectionURI().resolve("/MyCacheManagerName"))
              .timeouts(TimeoutsBuilder.timeouts().read(Duration.of(1, ChronoUnit.SECONDS)).build())
              .autoCreate()
              .defaultServerResource("primary-server-resource"))
      .withCache("simple-cache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated(4, MemoryUnit.MB))));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  final Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class);
  cache.put(1L, "un");
  cache.put(2L, "deux");
  cache.put(3L, "trois");

  assertThat(cache.containsKey(2L)).isTrue();

  cluster.getClusterControl().terminateAllServers();

  boolean value = new TimeLimitedTask<Boolean>(5, TimeUnit.SECONDS) {
    @Override
    Boolean runTask() throws Exception {
      return cache.containsKey(2L);
    }
  }.run();

  assertThat(value).isFalse();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Ignore("ClusteredStore.iterator() is not implemented")
@Test
public void testTerminationThenIterator() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(cluster.getConnectionURI().resolve("/MyCacheManagerName"))
            .timeouts(TimeoutsBuilder.timeouts().read(Duration.of(1, ChronoUnit.SECONDS)).build())
              .autoCreate()
              .defaultServerResource("primary-server-resource"))
      .withCache("simple-cache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated(4, MemoryUnit.MB))));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  final Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class);
  cache.put(1L, "un");
  cache.put(2L, "deux");
  cache.put(3L, "trois");

  cluster.getClusterControl().terminateAllServers();

  Iterator<Cache.Entry<Long, String>> value = new TimeLimitedTask<Iterator<Cache.Entry<Long,String>>>(5, TimeUnit.SECONDS) {
    @Override
    Iterator<Cache.Entry<Long, String>> runTask() throws Exception {
      return cache.iterator();
    }
  }.run();

  assertThat(value.hasNext()).isFalse();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testTerminationThenPut() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(cluster.getConnectionURI().resolve("/MyCacheManagerName"))
                  .timeouts(TimeoutsBuilder.timeouts().write(Duration.of(1, ChronoUnit.SECONDS)).build())
                  .autoCreate()
                  .defaultServerResource("primary-server-resource"))
      .withCache("simple-cache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated(4, MemoryUnit.MB))));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  final Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class);
  cache.put(1L, "un");
  cache.put(2L, "deux");
  cache.put(3L, "trois");

  cluster.getClusterControl().terminateAllServers();

  // The resilience strategy will pick it up and not exception is thrown
  new TimeLimitedTask<Void>(5, TimeUnit.SECONDS) {
    @Override
    Void runTask() throws Exception {
      cache.put(2L, "dos");
      return null;
    }
  }.run();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testClusteredCacheTwoClients() throws Exception {
  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      newCacheManagerBuilder()
          .with(cluster(CLUSTER_URI).autoCreate())
          .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100, EntryUnit.ENTRIES)
                  .with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))
              .add(new ClusteredStoreConfiguration(Consistency.STRONG)))
      ;

  final PersistentCacheManager cacheManager1 = clusteredCacheManagerBuilder.build(true);
  final PersistentCacheManager cacheManager2 = clusteredCacheManagerBuilder.build(true);

  final Cache<Long, String> cache1 = cacheManager1.getCache("clustered-cache", Long.class, String.class);
  final Cache<Long, String> cache2 = cacheManager2.getCache("clustered-cache", Long.class, String.class);

  assertThat(cache2.get(1L), nullValue());
  cache1.put(1L, "value1");
  assertThat(cache2.get(1L), is("value1"));
  assertThat(cache1.get(1L), is("value1"));
  cache1.put(1L, "value2");
  assertThat(cache2.get(1L), is("value2"));
  assertThat(cache1.get(1L), is("value2"));

  cacheManager2.close();
  cacheManager1.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testDestroyCacheManagerDoesNotAffectsExistingCacheWithExistingClientsConnected() throws CachePersistenceException {

  CacheManagerBuilder<PersistentCacheManager> cacheManagerBuilder = clusteredCacheManagerBuilder
      .withCache("test", newCacheConfigurationBuilder(Long.class, String.class,
          ResourcePoolsBuilder.newResourcePoolsBuilder()
              .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));

  PersistentCacheManager persistentCacheManager1 = cacheManagerBuilder.build(true);
  PersistentCacheManager persistentCacheManager2 = cacheManagerBuilder.build(true);

  persistentCacheManager1.close();
  try {
    persistentCacheManager1.destroy();
    fail("StateTransitionException expected");
  } catch (StateTransitionException e) {
    assertThat(e.getMessage(), is("Couldn't acquire cluster-wide maintenance lease"));
  }

  Cache<Long, String> cache = persistentCacheManager2.getCache("test", Long.class, String.class);

  cache.put(1L, "One");

  assertThat(cache.get(1L), is("One"));

  persistentCacheManager2.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testTerminationThenRemove() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(cluster.getConnectionURI().resolve("/MyCacheManagerName"))
                  .timeouts(TimeoutsBuilder.timeouts().write(Duration.of(1, ChronoUnit.SECONDS)).build())
                  .autoCreate()
                  .defaultServerResource("primary-server-resource"))
      .withCache("simple-cache",
          CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated(4, MemoryUnit.MB))));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  final Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class);
  cache.put(1L, "un");
  cache.put(2L, "deux");
  cache.put(3L, "trois");

  cluster.getClusterControl().terminateAllServers();

  new TimeLimitedTask<Void>(5, TimeUnit.SECONDS) {
    @Override
    Void runTask() throws Exception {
      cache.remove(2L);
      return null;
    }
  }.run();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testContainsKeyExpiredTwoClients() {

  TestTimeSource timeSource = new TestTimeSource();
  TimeSourceConfiguration timeSourceConfiguration = new TimeSourceConfiguration(timeSource);

  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      commonClusteredCacheManagerBuilder.using(timeSourceConfiguration);

  final PersistentCacheManager cacheManager1 = clusteredCacheManagerBuilder.build(true);
  final PersistentCacheManager cacheManager2 = clusteredCacheManagerBuilder.build(true);

  final Cache<Long, String> cache1 = cacheManager1.getCache("clustered-cache", Long.class, String.class);
  final Cache<Long, String> cache2 = cacheManager2.getCache("clustered-cache", Long.class, String.class);

  assertThat(cache2.get(1L), nullValue());
  cache1.put(1L, "value1");
  assertThat(cache1.containsKey(1L), is(true));
  timeSource.advanceTime(1L);

  assertThat(cache1.containsKey(1L), is(false));
  assertThat(cache2.containsKey(1L), is(false));

  cacheManager2.close();
  cacheManager1.close();

}