Java Code Examples for org.springframework.cache.Cache

protected <O> void manage(String key, O object, Action operation) {
    if (null == object) {
        return;
    }
    Cache cache = this.getCache();
    List<String> codes = (List<String>) this.get(cache, this.getCodesCacheKey(), List.class);
    if (Action.ADD.equals(operation)) {
        if (!codes.contains(key)) {
            codes.add(key);
            cache.put(this.getCodesCacheKey(), codes);
        }
        cache.put(this.getCacheKeyPrefix() + key, object);
    } else if (Action.UPDATE.equals(operation)) {
        if (!codes.contains(key)) {
            throw new CacheItemNotFoundException(key, cache.getName());
        }
        cache.put(this.getCacheKeyPrefix() + key, object);
    } else if (Action.DELETE.equals(operation)) {
        codes.remove(key);
        cache.evict(this.getCacheKeyPrefix() + key);
        cache.put(this.getCodesCacheKey(), codes);
    }
}
 

private void performCacheEvict(
		CacheOperationContext context, CacheEvictOperation operation, @Nullable Object result) {

	Object key = null;
	for (Cache cache : context.getCaches()) {
		if (operation.isCacheWide()) {
			logInvalidating(context, operation, null);
			doClear(cache);
		}
		else {
			if (key == null) {
				key = generateKey(context, result);
			}
			logInvalidating(context, operation, key);
			doEvict(cache, key);
		}
	}
}
 

@Test
void enableElasticache_configuredWithExplicitCluster_configuresExplicitlyConfiguredCaches()
		throws Exception {
	// Arrange

	// Act
	this.context = new AnnotationConfigApplicationContext(
			ApplicationConfigurationWithExplicitStackConfiguration.class);

	// Assert
	CacheManager cacheManager = this.context.getBean(CachingConfigurer.class)
			.cacheManager();
	assertThat(cacheManager.getCacheNames().size()).isEqualTo(2);
	Cache firstCache = cacheManager.getCache("firstCache");
	assertThat(firstCache.getName()).isNotNull();
	assertThat(getExpirationFromCache(firstCache)).isEqualTo(0);

	Cache secondCache = cacheManager.getCache("secondCache");
	assertThat(secondCache.getName()).isNotNull();
	assertThat(getExpirationFromCache(secondCache)).isEqualTo(0);
}
 

public V get(K key, ValueProvider<K, V> valueProvider) {
	V value;

	Cache.ValueWrapper valueWrapper = cache.get(key);
	if (valueWrapper == null) {
		synchronized (this) {
			valueWrapper = cache.get(key);
			if (valueWrapper == null) {
				value = valueProvider.getValue(key);
				cache.put(key, value);
			} else {
				value = (V) valueWrapper.get();
			}
		}
	} else {
		value = (V) valueWrapper.get();
	}

	return value;
}
 

public void loadUrlRoleMapping() {
    if(metadata != null){
        metadata.clear();
    }else{
        this.metadata = new HashMap<>();
    }
    //从缓存中获取数据
    Cache cache = cacheManager.getCache(ResourceCacheConstant.URL_ROLE_MAPPING_CACHE);
    Cache.ValueWrapper valueWrapper = cache.get(serviceId);
    Map<String, Set<String>> urlRoleMapping = null;
    if (valueWrapper != null) {
        urlRoleMapping = (Map<String, Set<String>>) valueWrapper.get();
    }
    //组装SpringSecurrty的数据
    if (urlRoleMapping != null) {
        for (Map.Entry<String, Set<String>> entry : urlRoleMapping.entrySet()) {
            Set<String> roleCodes = entry.getValue();
            Collection<ConfigAttribute> configs = CollectionUtils.collect(roleCodes.iterator(), input -> new SecurityConfig(input));
            this.metadata.put(entry.getKey(), configs);
        }
    }
}
 

@Test
public void earlyRemoveAllWithException() {
	Cache cache = getCache(DEFAULT_CACHE);

	Object key = createKey(name.getMethodName());
	cache.put(key, new Object());

	try {
		service.earlyRemoveAllWithException(true);
		fail("Should have thrown an exception");
	}
	catch (UnsupportedOperationException e) {
		// This is what we expect
	}
	assertTrue(isEmpty(cache));
}
 

@Test
public void testGetShoppingCartNullOrEmptyToken() throws Exception {

    final ShoppingCartStateService shoppingCartStateService = context.mock(ShoppingCartStateService.class, "shoppingCartStateService");
    final ShopService shopService = context.mock(ShopService.class, "shopService");
    final CartUpdateProcessor cartUpdateProcessor = context.mock(CartUpdateProcessor.class, "cartUpdateProcessor");
    final TaskExecutor taskExecutor = context.mock(TaskExecutor.class, "taskExecutor");
    final CacheManager cacheManager = context.mock(CacheManager.class, "cacheManager");
    final Cache cartCache = context.mock(Cache.class, "cartCache");

    context.checking(new Expectations() {{
        oneOf(cacheManager).getCache("web.shoppingCart"); will(returnValue(cartCache));
    }});

    final ResilientCartRepositoryImpl repo = new ResilientCartRepositoryImpl(shoppingCartStateService, shopService, cartUpdateProcessor, mockCartSerDes, 60, cacheManager, taskExecutor);

    assertNull(repo.getShoppingCart(null));
    assertNull(repo.getShoppingCart("  "));

    context.assertIsSatisfied();

}
 

@Override
public void testMultiEvict(CacheableService<?> service) {
	Object o1 = new Object();

	Object r1 = service.multiCache(o1);
	Object r2 = service.multiCache(o1);

	Cache primary = cm.getCache("primary");
	Cache secondary = cm.getCache("secondary");

	assertSame(r1, r2);
	assertSame(r1, primary.get(o1).get());
	assertSame(r1, secondary.get(o1).get());

	service.multiEvict(o1);
	assertNull(primary.get(o1));
	assertNull(secondary.get(o1));

	Object r3 = service.multiCache(o1);
	Object r4 = service.multiCache(o1);
	assertNotSame(r1, r3);
	assertSame(r3, r4);

	assertSame(r3, primary.get(o1).get());
	assertSame(r4, secondary.get(o1).get());
}
 

@Test
public void cacheCheckedException() {
	String keyItem = name.getMethodName();
	Cache cache = getCache(EXCEPTION_CACHE);

	Object key = createKey(keyItem);
	assertNull(cache.get(key));

	try {
		service.cacheWithCheckedException(keyItem, true);
		fail("Should have thrown an exception");
	}
	catch (IOException e) {
		// This is what we expect
	}

	Cache.ValueWrapper result = cache.get(key);
	assertNotNull(result);
	assertEquals(IOException.class, result.get().getClass());
}
 

@Override
public Cache getCache(String name) {
	Cache cache = this.cacheMap.get(name);
	if (cache != null) {
		return cache;
	}
	else {
		// Fully synchronize now for missing cache creation...
		synchronized (this.cacheMap) {
			cache = this.cacheMap.get(name);
			if (cache == null) {
				cache = getMissingCache(name);
				if (cache != null) {
					cache = decorateCache(cache);
					this.cacheMap.put(name, cache);
					updateCacheNames(name);
				}
			}
			return cache;
		}
	}
}
 

@Test
public void putWithExceptionVetoPut() {
	String keyItem = name.getMethodName();
	Cache cache = getCache(DEFAULT_CACHE);

	Object key = createKey(keyItem);
	Object value = new Object();
	assertNull(cache.get(key));

	try {
		service.putWithException(keyItem, value, false);
		fail("Should have thrown an exception");
	}
	catch (NullPointerException e) {
		// This is what we expect
	}
	assertNull(cache.get(key));
}
 

@Override
protected Collection<? extends Cache> loadCaches() {
  List<Cache> caches = new ArrayList<Cache>(initialCacheConfigs.size());
  for (Map.Entry<String, ArcusCacheConfiguration> entry : initialCacheConfigs.entrySet()) {
    caches.add(
      createCache(entry.getKey(), entry.getValue()));
  }

  return caches;
}
 

@Override
public Cache getCache(String name) {
    final Map<String, Cache> cacheMap = threadLocalCache.get();
    Cache cache = cacheMap.get(name);
    if (cache == null) {
        cache = createCache(name);
        cacheMap.put(name, cache);
    }
    return cache;
}
 

protected void insertObjectsOnCache(Cache cache, Map<String, O> objects) {
    List<String> codes = new ArrayList<>();
    Iterator<String> iter = objects.keySet().iterator();
    while (iter.hasNext()) {
        String key = iter.next();
        cache.put(this.getCacheKeyPrefix() + key, objects.get(key));
        codes.add(key);
    }
    cache.put(this.getCodesCacheKey(), codes);
}
 

@Test
public void testGetShoppingCartFromCacheLoggedOutInactiveNoSetting() throws Exception {

    final ShoppingCartStateService shoppingCartStateService = context.mock(ShoppingCartStateService.class, "shoppingCartStateService");
    final ShopService shopService = context.mock(ShopService.class, "shopService");
    final CartUpdateProcessor cartUpdateProcessor = context.mock(CartUpdateProcessor.class, "cartUpdateProcessor");
    final TaskExecutor taskExecutor = context.mock(TaskExecutor.class, "taskExecutor");
    final CacheManager cacheManager = context.mock(CacheManager.class, "cacheManager");
    final Cache cartCache = context.mock(Cache.class, "cartCache");
    final Cache.ValueWrapper wrapper = context.mock(Cache.ValueWrapper.class, "wrapper");
    final ShoppingCart cachedCart = context.mock(ShoppingCart.class, "cachedCart");

    final byte[] cached = new byte[0];

    context.checking(new Expectations() {{
        oneOf(cacheManager).getCache("web.shoppingCart"); will(returnValue(cartCache));
        oneOf(cartCache).get("IN-CACHE"); will(returnValue(wrapper));
        oneOf(wrapper).get(); will(returnValue(cached));
        oneOf(mockCartSerDes).restoreState(cached); will(returnValue(cachedCart));
        allowing(cachedCart).getLogonState(); will(returnValue(ShoppingCart.SESSION_EXPIRED));
    }});

    final ResilientCartRepositoryImpl repo = new ResilientCartRepositoryImpl(shoppingCartStateService, shopService, cartUpdateProcessor, mockCartSerDes, 60, cacheManager, taskExecutor);

    assertEquals(cachedCart, repo.getShoppingCart("IN-CACHE"));

    context.assertIsSatisfied();

}
 

protected Role getRoleFromCache(String id) {
    Cache cache = cacheManager.getCache(Role.Cache.NAME);
    Cache.ValueWrapper cachedValue = cache.get("id=" + id);
    if (cachedValue != null) {
        return (Role) cachedValue.get();
    }
    return null;
}
 

@Override
protected Collection<Cache> loadCaches() {
	CacheManager cacheManager = getCacheManager();
	Assert.state(cacheManager != null, "No CacheManager set");

	Collection<Cache> caches = new LinkedHashSet<>();
	for (String cacheName : cacheManager.getCacheNames()) {
		javax.cache.Cache<Object, Object> jcache = cacheManager.getCache(cacheName);
		caches.add(new JCacheCache(jcache, isAllowNullValues()));
	}
	return caches;
}
 

@Override
@SuppressWarnings("unchecked")
protected E handleCache(String key, CacheCallback<E> callback, Cache cache) {
    synchronized (key.intern()) {
        //еще раз читаем, т.к. в кэш могли положить пока ждали
        Cache.ValueWrapper valueWrapper = cache.get(key);
        if (valueWrapper != null) {
            E value = (E)valueWrapper.get();
            callback.doInCacheHit(value);
            return value;
        }
        return super.handleCache(key, callback, cache);
    }
}
 

private Cache.ValueWrapper findInCaches(CacheOperationContext context, Object key) {
	for (Cache cache : context.getCaches()) {
		Cache.ValueWrapper wrapper = doGet(cache, key);
		if (wrapper != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Cache entry for key '" + key + "' found in cache '" + cache.getName() + "'");
			}
			return wrapper;
		}
	}
	return null;
}
 

@Test
public void putTransactional() {
	Cache target = new ConcurrentMapCache("testCache");
	Cache cache = new TransactionAwareCacheDecorator(target);

	TransactionStatus status = this.txManager.getTransaction(
			new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED));

	Object key = new Object();
	cache.put(key, "123");
	assertNull(target.get(key));
	this.txManager.commit(status);

	assertEquals("123", target.get(key, String.class));
}
 

@Test
public void noCustomization() {
	Cache cache = cacheManager.getCache("default");

	Object key = new Object();
	assertCacheMiss(key, cache);

	Object value = simpleService.getSimple(key);
	assertCacheHit(key, value, cache);
}
 

/**
 * Execute {@link Cache#evict(Object)} on the specified {@link Cache} and
 * invoke the error handler if an exception occurs.
 */
protected void doEvict(Cache cache, Object key) {
	try {
		cache.evict(key);
	}
	catch (RuntimeException e) {
		getErrorHandler().handleCacheEvictError(e, cache, key);
	}
}
 

protected CacheResolver getCacheResolver(CacheInvocationContext<? extends Annotation> context, String cacheName) {
	CacheResolver cacheResolver = mock(CacheResolver.class);
	javax.cache.Cache cache;
	if (cacheName == null) {
		cache = null;
	}
	else {
		cache = mock(javax.cache.Cache.class);
		given(cache.getName()).willReturn(cacheName);
	}
	given(cacheResolver.resolveCache(context)).willReturn(cache);
	return cacheResolver;
}
 

/**
 * Convert the collection of caches in a single expected element.
 * <p>Throw an {@link IllegalStateException} if the collection holds more than one element
 * @return the singe element or {@code null} if the collection is empty
 */
static Cache extractFrom(Collection<? extends Cache> caches) {
	if (CollectionUtils.isEmpty(caches)) {
		return null;
	}
	else if (caches.size() == 1) {
		return caches.iterator().next();
	}
	else {
		throw new IllegalStateException("Unsupported cache resolution result " + caches +
				": JSR-107 only supports a single cache.");
	}
}
 

/**
 * Convert the collection of caches in a single expected element.
 * <p>Throw an {@link IllegalStateException} if the collection holds more than one element
 * @return the single element or {@code null} if the collection is empty
 */
@Nullable
static Cache extractFrom(Collection<? extends Cache> caches) {
	if (CollectionUtils.isEmpty(caches)) {
		return null;
	}
	else if (caches.size() == 1) {
		return caches.iterator().next();
	}
	else {
		throw new IllegalStateException("Unsupported cache resolution result " + caches +
				": JSR-107 only supports a single cache.");
	}
}
 

protected Role getRoleFromCache(String namespaceCode, String name) {
    Cache cache = cacheManager.getCache(Role.Cache.NAME);
    Cache.ValueWrapper cachedValue = cache.get("namespaceCode=" + namespaceCode + "|name=" + name);
    if (cachedValue != null) {
        return (Role) cachedValue.get();
    }
    return null;
}
 

@Override
protected Collection<Cache> loadCaches() {
	Collection<Cache> caches = new LinkedHashSet<Cache>();
	for (String cacheName : getCacheManager().getCacheNames()) {
		javax.cache.Cache<Object, Object> jcache = getCacheManager().getCache(cacheName);
		caches.add(new JCacheCache(jcache, isAllowNullValues()));
	}
	return caches;
}
 

/**
 * Execute {@link Cache#put(Object, Object)} on the specified {@link Cache}
 * and invoke the error handler if an exception occurs.
 */
protected void doPut(Cache cache, Object key, @Nullable Object result) {
	try {
		cache.put(key, result);
	}
	catch (RuntimeException ex) {
		getErrorHandler().handleCachePutError(ex, cache, key, result);
	}
}
 

@SuppressWarnings("unchecked")
@Override
protected S handleSecondCache(String key, TwoLevelCacheCallback<F, S> callback, Cache secondLevelCache) {
    synchronized (key.intern()) {
        //еще раз читаем, т.к. в кэш могли положить пока ждали
        Cache.ValueWrapper valueWrapper = secondLevelCache.get(key);
        if (valueWrapper != null) {
            S value = (S) valueWrapper.get();
            callback.doInSecondLevelCacheHit(value);
            return value;
        }
        return super.handleSecondCache(key, callback, secondLevelCache);
    }
}
 

@Override
public void initCache(Map<String, ApiResource> resources, IApiCatalogDAO apiCatalogDAO) throws ApsSystemException {
	try {
		Cache cache = this.getCache();
		this.releaseCachedObjects(cache);
		apiCatalogDAO.loadApiStatus(resources);
		this.insertObjectsOnCache(cache, resources);
	} catch (Throwable t) {
		logger.error("Error bootstrapping ApiCatalog cache", t);
		throw new ApsSystemException("Error bootstrapping ApiCatalog cache", t);
	}
}