Java PersistentCacheManager.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")))
    .withCache("threeTieredCache",
      CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.newResourcePoolsBuilder()
          .heap(10, EntryUnit.ENTRIES)
          .offheap(1, MemoryUnit.MB)
          .disk(20, MemoryUnit.MB, true)
      )
    ).build(true);
  // end::threeTiersCacheManager[]

  persistentCacheManager.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
  public void testPersistentDiskCache() throws Exception {
    CacheConfiguration<Long, String> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).disk(10L, MemoryUnit.MB, true))
        .build();

    PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
        .with(new CacheManagerPersistenceConfiguration(new File(getClass().getClassLoader().getResource(".").toURI().getPath() + "/../../persistent-cache-data")))
        .withCache("persistent-cache", cacheConfiguration)
        .build(true);

    Cache<Long, String> cache = persistentCacheManager.getCache("persistent-cache", Long.class, String.class);

    // Comment the following line on subsequent run and see the test pass
    cache.put(42L, "That's the answer!");
    assertThat(cache.get(42L), is("That's the answer!"));

    // Uncomment the following line to nuke the disk store
//    persistentCacheManager.destroyCache("persistent-cache");

    persistentCacheManager.close();
  }
 

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

  DedicatedClusteredResourcePool resourcePool = ClusteredResourcePoolBuilder.clusteredDedicated(10, MemoryUnit.KB);
  CacheManagerBuilder<PersistentCacheManager> cacheManagerBuilder = getPersistentCacheManagerCacheManagerBuilder(resourcePool);

  try {
    cacheManagerBuilder.build(true);
    fail("InvalidServerStoreConfigurationException expected");
  } catch (Exception e) {
    Throwable cause = getCause(e, CachePersistenceException.class);
    assertThat(cause, notNullValue());
    assertThat(cause.getMessage(), startsWith("Unable to create"));
  }
  resourcePool = ClusteredResourcePoolBuilder.clusteredDedicated(100, MemoryUnit.KB);
  cacheManagerBuilder = getPersistentCacheManagerCacheManagerBuilder(resourcePool);
  PersistentCacheManager persistentCacheManager = cacheManagerBuilder.build(true);

  assertThat(persistentCacheManager, notNullValue());
  persistentCacheManager.close();

}
 

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

  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder
      = CacheManagerBuilder.newCacheManagerBuilder()
      .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application"))
          .autoCreate());
  final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true);

  try {
    CacheConfiguration<Long, String> config = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.newResourcePoolsBuilder()
            .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 8, MemoryUnit.MB)))
        .withLoaderWriter(new TestLoaderWriter())
        .build();

    cacheManager.createCache("test", config);
    fail("IllegalStateException expected");
  } catch (IllegalStateException e){
    assertThat(e.getCause().getMessage(), is("CacheLoaderWriter is not supported with clustered tiers"));
  }
  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 threeTiersCacheManager() throws Exception {
  // tag::threeTiersCacheManager[]
  PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
    .with(cluster(CLUSTER_URI).autoCreate()) // <1>
    .withCache("threeTierCache",
      CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.newResourcePoolsBuilder()
          .heap(10, EntryUnit.ENTRIES) // <2>
          .offheap(1, MemoryUnit.MB) // <3>
          .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)) // <4>
      )
    ).build(true);
  // end::threeTiersCacheManager[]

  persistentCacheManager.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void clusteredCacheManagerWithDynamicallyAddedCacheExample() throws Exception {
  // tag::clusteredCacheManagerWithDynamicallyAddedCacheExample[]
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder
          = CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application"))
                  .autoCreate()
                  .defaultServerResource("primary-server-resource")
                  .resourcePool("resource-pool-a", 28, MemoryUnit.MB));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  try {
    CacheConfiguration<Long, String> config = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
            ResourcePoolsBuilder.newResourcePoolsBuilder()
                    .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))).build();

    Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config);

  } finally {
    cacheManager.close();
  }
  // end::clusteredCacheManagerWithDynamicallyAddedCacheExample[]
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void clusteredCacheManagerWithServerSideConfigExample() throws Exception {
  // tag::clusteredCacheManagerWithServerSideConfigExample[]
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application")).autoCreate()
              .defaultServerResource("primary-server-resource") // <1>
              .resourcePool("resource-pool-a", 28, MemoryUnit.MB, "secondary-server-resource") // <2>
              .resourcePool("resource-pool-b", 32, MemoryUnit.MB)) // <3>
          .withCache("clustered-cache", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, // <4>
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 32, MemoryUnit.MB)))) // <5>
          .withCache("shared-cache-1", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredShared("resource-pool-a")))) // <6>
          .withCache("shared-cache-2", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredShared("resource-pool-a")))); // <7>
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); // <8>

  cacheManager.close();
  // end::clusteredCacheManagerWithServerSideConfigExample[]
}
 

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

  cacheManager.close();
  cacheManager.destroy();

  cacheManager.init();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testDestroyCacheManagerWithMultipleClients() throws CachePersistenceException {
  PersistentCacheManager persistentCacheManager1 = clusteredCacheManagerBuilder.build(true);
  PersistentCacheManager persistentCacheManager2 = clusteredCacheManagerBuilder.build(true);

  persistentCacheManager1.close();

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

  assertThat(persistentCacheManager1.getStatus(), is(Status.UNINITIALIZED));

  assertThat(persistentCacheManager2.getStatus(), is(Status.AVAILABLE));

  Cache<Long, String> cache = persistentCacheManager2.createCache("test", newCacheConfigurationBuilder(Long.class, String.class,
      ResourcePoolsBuilder.newResourcePoolsBuilder()
          .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB))));

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

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

  persistentCacheManager2.close();
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testXACacheWithThreeTiers() throws Exception {
  // tag::testXACacheWithThreeTiers[]
  BitronixTransactionManager transactionManager =
      TransactionManagerServices.getTransactionManager(); // <1>

  PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
      .using(new LookupTransactionManagerProviderConfiguration(BitronixTransactionManagerLookup.class)) // <2>
      .with(CacheManagerBuilder.persistence(new File(getStoragePath(), "testXACacheWithThreeTiers"))) // <3>
      .withCache("xaCache", CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, // <4>
              ResourcePoolsBuilder.newResourcePoolsBuilder() // <5>
                      .heap(10, EntryUnit.ENTRIES)
                      .offheap(10, MemoryUnit.MB)
                      .disk(20, MemoryUnit.MB, true)
              )
              .add(new XAStoreConfiguration("xaCache")) // <6>
              .build()
      )
      .build(true);

  final Cache<Long, String> xaCache = persistentCacheManager.getCache("xaCache", Long.class, String.class);

  transactionManager.begin(); // <7>
  {
    xaCache.put(1L, "one"); // <8>
  }
  transactionManager.commit(); // <9>

  persistentCacheManager.close();
  transactionManager.shutdown();
  // end::testXACacheWithThreeTiers[]
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void explicitConsistencyConfiguration() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder
          = CacheManagerBuilder.newCacheManagerBuilder()
          .with(ClusteringServiceConfigurationBuilder.cluster(URI.create("terracotta://localhost/my-application"))
                  .autoCreate()
                  .defaultServerResource("primary-server-resource")
                  .resourcePool("resource-pool-a", 32, MemoryUnit.MB));
  PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  try {
    // tag::clusteredCacheConsistency[]
    CacheConfiguration<Long, String> config = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
            ResourcePoolsBuilder.newResourcePoolsBuilder()
                    .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))
        .add(ClusteredStoreConfigurationBuilder.withConsistency(Consistency.STRONG)) // <1>
        .build();

    Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config);
    cache.put(42L, "All you need to know!"); // <2>

    // end::clusteredCacheConsistency[]
  } finally {
    cacheManager.close();
  }
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test(timeout = 150000)
public void testSync() throws Exception {
  CLUSTER.getClusterControl().terminateOnePassive();

  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder
    = CacheManagerBuilder.newCacheManagerBuilder()
    .with(ClusteringServiceConfigurationBuilder.cluster(CLUSTER.getConnectionURI().resolve("/op-sync"))
      .autoCreate()
      .defaultServerResource("primary-server-resource"));
  final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(false);
  cacheManager.init();

  try {
    CacheConfiguration<Long, String> config = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
      ResourcePoolsBuilder.newResourcePoolsBuilder()
        .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 1, MemoryUnit.MB))).build();

    Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config);

    for (long i = -5; i < 5; i++) {
      cache.put(i, "value" + i);
    }

    CLUSTER.getClusterControl().startOneServer();
    CLUSTER.getClusterControl().waitForRunningPassivesInStandby();
    CLUSTER.getClusterControl().terminateActive();
    CLUSTER.getClusterControl().waitForActive();

    // Sometimes the new passive believes there is a second connection and we have to wait for the full reconnect window before getting a result
    waitOrTimeout(() -> "value-5".equals(cache.get(-5L)), timeout(seconds(130)));

    for (long i = -4; i < 5; i++) {
      assertThat(cache.get(i), equalTo("value" + i));
    }
  } finally {
    cacheManager.close();
  }
}
 

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

  // Should lock the file when the CacheManager is opened
  assertThat(rootDirectory, isLocked());

  manager.close(); // pass it to uninitialized

  // Should unlock the file when the CacheManager is closed
  assertThat(rootDirectory, not(isLocked()));
}