Java PersistentCacheManager.destroy方法代码示例

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testDestroyCacheManager() throws Exception {
  CacheManagerBuilder<PersistentCacheManager> configBuilder = newCacheManagerBuilder().with(cluster(CLUSTER.getConnectionURI().resolve("/destroy-CM"))
    .autoCreate().defaultServerResource("primary-server-resource"));
  PersistentCacheManager cacheManager1 = configBuilder.build(true);
  PersistentCacheManager cacheManager2 = configBuilder.build(true);

  cacheManager2.close();

  try {
    cacheManager2.destroy();
    fail("Exception expected");
  } catch (Exception e) {
    e.printStackTrace();
  }

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

  cacheManager1.createCache("test", newCacheConfigurationBuilder(Long.class, String.class, heap(10).with(clusteredDedicated(10, MB))));
}
 

import org.ehcache.PersistentCacheManager; //导入方法依赖的package包/类
@Test
public void testCanDestroyAndClose() throws Exception {
  CacheConfiguration<Long, String> cacheConfiguration = new BaseCacheConfiguration<>(Long.class, String.class, null,
    null, null, ResourcePoolsHelper.createHeapOnlyPools(10));

  Store.Provider storeProvider = mock(Store.Provider.class);
  when(storeProvider.rank(any(Set.class), any(Collection.class))).thenReturn(1);
  Store store = mock(Store.class);
  CacheEventDispatcherFactory cacheEventNotificationListenerServiceProvider = mock(CacheEventDispatcherFactory.class);

  when(storeProvider.createStore(any(Store.Configuration.class), ArgumentMatchers.<ServiceConfiguration>any())).thenReturn(store);
  when(store.getConfigurationChangeListeners()).thenReturn(new ArrayList<>());
  when(cacheEventNotificationListenerServiceProvider.createCacheEventDispatcher(store)).thenReturn(mock(CacheEventDispatcher.class));

  Map<String, CacheConfiguration<?, ?>> caches = newCacheMap();
  caches.put("aCache", cacheConfiguration);
  DefaultConfiguration config = new DefaultConfiguration(caches, null);
  PersistentCacheManager cacheManager = new EhcacheManager(config, Arrays.asList(
      storeProvider,
      mock(CacheLoaderWriterProvider.class),
      mock(WriteBehindProvider.class),
      cacheEventNotificationListenerServiceProvider,
      mock(CacheEventListenerProvider.class),
      mock(LocalPersistenceService.class)));
  cacheManager.init();

  cacheManager.close();
  cacheManager.init();
  cacheManager.close();
  cacheManager.destroy();
  cacheManager.init();
  cacheManager.close();
}
 

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

  persistentCacheManager.close();
  persistentCacheManager.destroy();

  assertThat(persistentCacheManager.getStatus(), is(Status.UNINITIALIZED));
}
 

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 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();
}