Java ConcurrentMapCacheManager类代码示例

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
private Cache getCache(final String cacheName) {

        Cache cache = cm.getCache(CacheNames.JWKS);
        if (cache == null) {
            LOG.warn("A no cache named {} was not provided by the cache manager an in-memory cache will be used", cacheName);
            cache = new ConcurrentMapCacheManager(cacheName).getCache(cacheName);
        }
        return cache;

    }
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void customizeSimpleCacheManager() {
	load(SimpleConfiguration.class, "spring.cache.type=simple");
	ConcurrentMapCacheManager cacheManager = this.context
			.getBean(ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames()).containsOnly("one", "two");
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Bean
public CacheManagerCustomizer<ConcurrentMapCacheManager> cacheManagerCustomizer() {
	return new CacheManagerCustomizer<ConcurrentMapCacheManager>() {

		@Override
		public void customize(ConcurrentMapCacheManager cacheManager) {
			cacheManager.setCacheNames(Arrays.asList("one", "two"));
		}

	};
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void cacheManagerBackOff() {
	load(CustomCacheManagerConfiguration.class);
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames()).containsOnly("custom1");
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void cacheManagerFromSupportBackOff() {
	load(CustomCacheManagerFromSupportConfiguration.class);
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames()).containsOnly("custom1");
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void simpleCacheExplicit() {
	load(DefaultCacheConfiguration.class, "spring.cache.type=simple");
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames()).isEmpty();
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void simpleCacheExplicitWithCacheNames() {
	load(DefaultCacheConfiguration.class, "spring.cache.type=simple",
			"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar");
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void whenSpringCacheTypeIsSimpleThenSimpleCacheLoaded() {
    loadContext(CacheConfiguration.class, "spring.cache.type=simple");

    CacheManager cacheManager = this.applicationContext.getBean(CacheManager.class);

    assertThat(cacheManager).isInstanceOf(ConcurrentMapCacheManager.class);
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void whenUsingCustomCacheManagerThenMemcachedCustomCacheManagerLoaded() {
    loadContext(CacheWithCustomCacheManagerConfiguration.class);

    CacheManager cacheManager = this.applicationContext.getBean(CacheManager.class);

    assertThat(cacheManager).isInstanceOf(ConcurrentMapCacheManager.class);
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void cacheManagerBackOff() {
	load(CustomCacheManagerConfiguration.class);
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames(), contains("custom1"));
	assertThat(cacheManager.getCacheNames(), hasSize(1));
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void cacheManagerFromSupportBackOff() {
	load(CustomCacheManagerFromSupportConfiguration.class);
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames(), contains("custom1"));
	assertThat(cacheManager.getCacheNames(), hasSize(1));
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void simpleCacheExplicit() {
	load(DefaultCacheConfiguration.class, "spring.cache.type=simple");
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames(), empty());
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Test
public void simpleCacheExplicitWithCacheNames() {
	load(DefaultCacheConfiguration.class, "spring.cache.type=simple",
			"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar");
	ConcurrentMapCacheManager cacheManager = validateCacheManager(
			ConcurrentMapCacheManager.class);
	assertThat(cacheManager.getCacheNames(), containsInAnyOrder("foo", "bar"));
	assertThat(cacheManager.getCacheNames(), hasSize(2));
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
@Bean
public CacheManager cacheManager() {	
	LOG.info("ACTIVANDO CACHE!!!");	
	return new ConcurrentMapCacheManager("saleweb"); 
}
 

import org.springframework.cache.concurrent.ConcurrentMapCacheManager; //导入依赖的package包/类
/**
 * Construct a dynamic {@link FluuzCacheManager} backed by a {@link ConcurrentMapCacheManager}, 
 * lazily creating cache instances as they are being requested.
 */
public FluuzCacheManager(EventManager eventManager) {
    this.eventManager = eventManager;
    proxy = new ConcurrentMapCacheManager();
}