Java Code Examples for org.ehcache.Cache#putAll()

@Test
public void testSimplePutAllWithEviction() throws Exception {
  Cache<Number, CharSequence> testCache = cacheManager.createCache("testCache",
      CacheConfigurationBuilder.newCacheConfigurationBuilder(Number.class, CharSequence.class, heap(2))
          .build());

  Map<Integer, String> values = new HashMap<>();
  values.put(1, "one");
  values.put(2, "two");
  values.put(3, "three");
  values.put(4, "four");

  testCache.putAll(values);

  int count = 0;
  for (@SuppressWarnings("unused") Cache.Entry<Number, CharSequence> entry : testCache) {
    count++;
  }
  assertThat(count, is(2));
}
 

@Test
public void testPutAll_without_cache_writer() throws Exception {
  CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class,
      heap(100));
  CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build();

  CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder();
  CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);

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

  HashMap<String, String> stringStringHashMap = new HashMap<>();
  for (int i = 0; i < 3; i++) {
    stringStringHashMap.put("key" + i, "value" + i);
  }

  // the call to putAll
  myCache.putAll(stringStringHashMap);

  for (int i = 0; i < 3; i++) {
    assertThat(myCache.get("key" + i), is("value" + i));
  }

}
 

@Test
public void testSimplePutAll() throws Exception {
  Cache<Number, CharSequence> testCache = cacheManager.createCache("testCache", newCacheConfigurationBuilder(Number.class, CharSequence.class, heap(10)));

  Map<Integer, String> values = new HashMap<>();
  values.put(1, "one");
  values.put(2, "two");
  values.put(3, "three");

  testCache.putAll(values);

  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one"));
  assertThat(testCache.get(2), Matchers.<CharSequence>equalTo("two"));
  assertThat(testCache.get(3), Matchers.<CharSequence>equalTo("three"));
}
 

@Test
public void testPutAll_with_cache_writer_that_throws_exception() throws Exception {
  CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class,
      heap(100));

  CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
  CacheLoaderWriter cacheLoaderWriterThatThrows = mock(CacheLoaderWriter.class);
  doThrow(new RuntimeException("We should not have called .write() but .writeAll()")).when(cacheLoaderWriterThatThrows).write(ArgumentMatchers
      .any(), ArgumentMatchers.any());
  doThrow(new Exception("Simulating an exception from the cache writer")).when(cacheLoaderWriterThatThrows).writeAll(ArgumentMatchers.any(Iterable.class));
  when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriterThatThrows);

  CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider);
  CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.withLoaderWriter(cacheLoaderWriterThatThrows).build();
  CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);

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

  HashMap<String, String> stringStringHashMap = new HashMap<>();
  for (int i = 0; i < 3; i++) {
    stringStringHashMap.put("key" + i, "value" + i);
  }

  // the call to putAll
  try {
    myCache.putAll(stringStringHashMap);
    fail();
  } catch (BulkCacheWritingException bcwe) {
    assertThat(bcwe.getFailures().size(), is(3));
    assertThat(bcwe.getSuccesses().size(), is(0));
  }

}
 

@Test
  public void testPutAll_store_throws_cache_exception() throws Exception {
    CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class,
        heap(100));
    CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder
        .build();


    CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
    CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class);
    doThrow(new RuntimeException("We should not have called .write() but .writeAll()")).when(cacheLoaderWriter).write(ArgumentMatchers.any(), ArgumentMatchers.any());
    when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriter);

    CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider).using(new CustomStoreProvider());
    CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);

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

    Map<String, String> stringStringHashMap = new HashMap<>();
    for (int i = 0; i < 3; i++) {
      stringStringHashMap.put("key" + i, "value" + i);
    }

    // the call to putAll
    myCache.putAll(stringStringHashMap);

    for (int i = 0; i < 3; i++) {
      // the store threw an exception when we call bulkCompute
      assertThat(myCache.get("key" + i), is(nullValue()));
      // but still, the cache writer could writeAll the values !
//      assertThat(cacheWriterToHashMapMap.get("key" + i), is("value" + i));
    }
    // but still, the cache writer could writeAll the values at once !
    verify(cacheLoaderWriter, times(1)).writeAll(ArgumentMatchers.any(Iterable.class));
    Set set = new HashSet() {{add(entry("key0", "value0")); add(entry("key1", "value1")); add(entry("key2", "value2"));}};
    verify(cacheLoaderWriter).writeAll(set);
  }
 

@Override
protected void insert(Cache<Number, CharSequence> testCache, Map<Number, CharSequence> entries) {
  testCache.putAll(entries);
}
 

@Test
public void testBulkWrites() throws Exception {
  WriteBehindTestLoaderWriter<String, String> loaderWriter = new WriteBehindTestLoaderWriter<>();
  CacheLoaderWriterProvider cacheLoaderWriterProvider = getMockedCacheLoaderWriterProvider(loaderWriter);

  try (CacheManager cacheManager = managerBuilder().using(cacheLoaderWriterProvider).build(true)) {
    Cache<String, String> testCache = cacheManager.createCache("testBulkWrites", CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100))
      .withLoaderWriter(loaderWriter)
      .withService(newUnBatchedWriteBehindConfiguration().concurrencyLevel(3).queueSize(10).build())
      .build());

    CountDownLatch countDownLatch = new CountDownLatch(20);
    loaderWriter.setLatch(countDownLatch);
    for (int i = 0; i < 10; i++)
      testCache.put("test" + i, "test" + i);

    Map<String, String> entries = new HashMap<>(10);
    Set<String> keys = new HashSet<>(10);
    for (int i = 10; i < 20; i++) {
      entries.put("test" + i, "test" + i);
      keys.add("test" + i);
    }

    testCache.putAll(entries);
    countDownLatch.await(5, SECONDS);
    for (int i = 0; i < 20; i++) {
      assertThat("Key : " + i, loaderWriter.getData().get("test" + i), contains("test" + i));
    }

    CountDownLatch countDownLatch1 = new CountDownLatch(10);
    loaderWriter.setLatch(countDownLatch1);
    testCache.removeAll(keys);

    countDownLatch1.await(5, SECONDS);

    assertThat(loaderWriter.getData().size(), is(20));
    for (int i = 0; i < 10; i++) {
      assertThat("Key : " + i, loaderWriter.getData().get("test" + i), contains("test" + i));
    }
    for (int i = 10; i < 20; i++) {
      assertThat("Key : " + i, loaderWriter.getData().get("test" + i), contains("test" + i, null));
    }
  }
}
 

@Test
public void basicClusteredBulk() throws Exception {
  final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder =
      newCacheManagerBuilder()
          .with(cluster(CLUSTER.getConnectionURI().resolve("/bulk-cm")).autoCreate(c -> c))
          .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class,
              ResourcePoolsBuilder.newResourcePoolsBuilder()
                  .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))
              .withService(new ClusteredStoreConfiguration(Consistency.STRONG)));

  try (PersistentCacheManager cacheManager1 = clusteredCacheManagerBuilder.build(true)) {

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

      Map<Long, String> entriesMap = new HashMap<>();
      entriesMap.put(1L, "one");
      entriesMap.put(2L, "two");
      entriesMap.put(3L, "three");
      cache1.putAll(entriesMap);

      Set<Long> keySet = new HashSet<>(Arrays.asList(1L, 2L, 3L));
      Map<Long, String> all = cache2.getAll(keySet);
      assertThat(all.get(1L), is("one"));
      assertThat(all.get(2L), is("two"));
      assertThat(all.get(3L), is("three"));

      Map<Long, String> entries1 = new HashMap<>();
      assertThat(cache1, iterableWithSize(3));
      cache1.forEach(e -> entries1.putIfAbsent(e.getKey(), e.getValue()));
      assertThat(entries1, hasEntry(1L, "one"));
      assertThat(entries1, hasEntry(2L, "two"));
      assertThat(entries1, hasEntry(3L, "three"));

      Map<Long, String> entries2 = new HashMap<>();
      assertThat(cache2, iterableWithSize(3));
      cache2.forEach(e -> entries2.putIfAbsent(e.getKey(), e.getValue()));
      assertThat(entries2, hasEntry(1L, "one"));
      assertThat(entries2, hasEntry(2L, "two"));
      assertThat(entries2, hasEntry(3L, "three"));
      cache2.removeAll(keySet);

      all = cache1.getAll(keySet);
      assertThat(all.get(1L), nullValue());
      assertThat(all.get(2L), nullValue());
      assertThat(all.get(3L), nullValue());
    }
  }
}
 

@Test
public void testBulkOps() {
  TestCacheLoaderWriter loaderWriter = new TestCacheLoaderWriter();
  CacheConfiguration<Long, String> cacheConfiguration = getCacheConfiguration(loaderWriter);

  try (CacheManager cacheManager = CacheManagerBuilder
          .newCacheManagerBuilder()
          .with(cluster(CLUSTER_URI).autoCreate(c -> c))
          .withCache("cache-1", cacheConfiguration)
          .build(true)) {

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

    Map<Long, String> mappings = new HashMap<>();

    for (int i = 1; i <= 5; i++) {
      mappings.put((long) i, "" + i);
    }

    cache.putAll(mappings);

    assertThat(loaderWriter.storeMap.keySet(), containsInAnyOrder(mappings.keySet().toArray()));

    cache.clear();

    Map<Long, String> loadedData = cache.getAll(mappings.keySet());

    assertThat(mappings.keySet(), containsInAnyOrder(loadedData.keySet().toArray()));

    cache.removeAll(mappings.keySet());

    assertThat(loaderWriter.storeMap.isEmpty(), is(true));
  }
}