@SuppressWarnings("unchecked") @Override public Object load(final Object key) throws net.sf.ehcache.CacheException { return loader.load((K) key); }
@Override public V get() { return loader.load(key); }
@SuppressWarnings("unchecked") @Override public Map loadAll(final Collection keys) { Map<K, V> map = new HashMap<K, V>(); for (Object key : keys) { final V value = loader.load((K) key); if (value != null) { map.put((K) key, value); } } return map; }
@SuppressWarnings("unchecked") @Override @Nonnull public Object load(@Nonnull final Object key) throws CacheException { return valueProcessor.wrap(delegate.load(valueProcessor.unwrap(key))); } }
@Nonnull @Override public V load(@Nonnull K key) { V v; long currentVersion; do { currentVersion = cacheVersion.get(); v = delegate.load(key); } while (currentVersion != cacheVersion.get()); return v; } }
@Nonnull @Override public V get(final K key) { notNull("key", key); final RequestCacheController.CacheContext cacheContext = getContext(); if (cacheContext == null) { // no cache in context - load it the slow way each time return getNotNull("cacheLoader", key, cacheLoader.load(key)); } final Map<Object, Object> localMap = cacheContext.getLocalMap(this); final Object cachedValue = localMap.get(key); if (cachedValue != null) { //noinspection unchecked return (V)cachedValue; } final V loadedValue = getNotNull("cacheLoader", key, cacheLoader.load(key)); localMap.put(key, loadedValue); return loadedValue; }
@Test public void testOnRemoveCanGet() throws Exception { CacheLoader<String, String> cacheLoader = mock(CacheLoader.class); when(cacheLoader.load("remove")).thenReturn("REMOVE"); Map<String, String> removedValues = mock(Map.class); Cache<String, String> cache = factory.getCache("REMOVE_CACHE", cacheLoader, settingsBuilder().build()); CacheEntryListener listener = new CacheEntryAdapter<String, String>() { @Override public void onRemove(@Nonnull CacheEntryEvent<String, String> event) { String key = event.getKey(); removedValues.put(key, cache.get(key)); } }; cache.addListener(listener, true); cache.get("remove"); cache.remove("remove"); verify(removedValues, timeout(2000)).put(eq("remove"), eq("REMOVE")); }
@Override public V get(@Nonnull final K key) { rejectNullKey(key); if (theLoader == null) { V value = internalCache.getIfPresent(key); if (isCollectorStatisticsEnabled()) { if (value == null) { collector.miss(); } else { collector.hit(); } } return value; } else { return get(key, () -> theLoader.load(key)); } }
@SuppressWarnings({ "ConstantConditions", "unchecked" }) private V getFromLoader(Object key) { final V value; try { value = loader.load((K)key); } catch (final RuntimeException re) { put(new Element(key, null)); throw propagate(key, re); } catch (final Error err) { put(new Element(key, null)); throw propagate(key, err); } if (value == null) { throw new CacheException("CacheLoader returned null for key " + key); } return value; }
@Test public void testOnAdd() throws Exception { CacheLoader<String, String> cacheLoader = mock(CacheLoader.class); when(cacheLoader.load("add")).thenReturn("ADD"); Cache<String, String> cache = factory.getCache("ADD_CACHE", cacheLoader, settingsBuilder().build()); CacheEntryListener listener = mock(CacheEntryListener.class); cache.addListener(listener, true); cache.get("add"); ArgumentCaptor<CacheEntryEvent> captor = ArgumentCaptor.forClass(CacheEntryEvent.class); verify(listener, timeout(1000)).onAdd(captor.capture()); CacheEntryEvent<String, String> event = captor.getValue(); assertEquals("add", event.getKey()); assertNull(event.getOldValue()); if (supportsAddValue()) { assertEquals("ADD", event.getValue()); } else { assertNull(event.getValue()); } }
@Test public void testOnRemove() throws Exception { CacheLoader<String, String> cacheLoader = mock(CacheLoader.class); when(cacheLoader.load("remove")).thenReturn("REMOVE"); Cache<String, String> cache = factory.getCache("REMOVE_CACHE", cacheLoader, settingsBuilder().build()); CacheEntryListener listener = mock(CacheEntryListener.class); cache.addListener(listener, true); cache.get("remove"); cache.remove("remove"); ArgumentCaptor<CacheEntryEvent> captor = ArgumentCaptor.forClass(CacheEntryEvent.class); verify(listener, timeout(1000)).onRemove(captor.capture()); CacheEntryEvent<String, String> event = captor.getValue(); assertEquals("remove", event.getKey()); if (supportsRemoveOldValue()) { assertEquals("REMOVE", event.getOldValue()); } else { assertNull(event.getOldValue()); } assertNull(event.getValue()); }
@Test public void testOnEvict() throws Exception { CacheLoader<String, String> cacheLoader = mock(CacheLoader.class); when(cacheLoader.load("evict")).thenReturn("EVICT"); Cache<String, String> cache = factory.getCache("EVICT_CACHE", cacheLoader, settingsBuilder().expireAfterAccess(1, TimeUnit.SECONDS).expireAfterWrite(1, TimeUnit.SECONDS).build()); CacheEntryListener<String,String> listener = mock(CacheEntryListener.class); cache.addListener(listener, true); cache.get("evict"); Thread.sleep(2000); cache.get("evict"); ArgumentCaptor<CacheEntryEvent> captor = ArgumentCaptor.forClass(CacheEntryEvent.class); verify(listener, timeout(2000).atLeastOnce()).onEvict(captor.capture()); CacheEntryEvent<String, String> event = captor.getValue(); assertEquals("evict", event.getKey()); if (supportsEvictOldValue()) { assertEquals("EVICT", event.getOldValue()); } else { assertNull(event.getOldValue()); } assertNull(event.getValue()); }
when(cacheLoader.load("update")).thenReturn("UPDATE");
when(cacheLoader.load("replace")).thenReturn("REPLACE");