org.springframework.cache.caffeine.CaffeineCacheManager Java Examples

@Test
void loadBalancerCacheShouldNotOverrideExistingCaffeineCacheManager() {
	ApplicationContextRunner contextRunner = baseApplicationRunner()
			.withUserConfiguration(TestConfiguration.class);

	contextRunner.run(context -> {
		assertThat(context.getBeansOfType(CacheManager.class)).hasSize(2);
		assertThat(context.getBean("cacheManager"))
				.isInstanceOf(CaffeineCacheManager.class);
		assertThat(((CacheManager) context.getBean("cacheManager")).getCacheNames())
				.isEmpty();
		assertThat(
				((CacheManager) context.getBean("caffeineLoadBalancerCacheManager"))
						.getCacheNames()).hasSize(1);
		assertThat(
				((CacheManager) context.getBean("caffeineLoadBalancerCacheManager"))
						.getCacheNames())
								.contains("CachingServiceInstanceListSupplierCache");
	});

}
 

@Test
void shouldAutoEnableCaching() {
	ApplicationContextRunner contextRunner = baseApplicationRunner();

	contextRunner.run(context -> {
		assertThat(context.getBeansOfType(CacheManager.class)).hasSize(1);
		assertThat(
				((CacheManager) context.getBean("caffeineLoadBalancerCacheManager"))
						.getCacheNames()).hasSize(1);
		assertThat(context.getBean("caffeineLoadBalancerCacheManager"))
				.isInstanceOf(CaffeineCacheManager.class);
		assertThat(
				((CacheManager) context.getBean("caffeineLoadBalancerCacheManager"))
						.getCacheNames())
								.contains("CachingServiceInstanceListSupplierCache");
	});
}
 

/**
 * Create a new cache provider based on Caffeine and Spring Cache.
 *
 * @param minCacheSize The minimum size of the cache.
 * @param maxCacheSize the maximum size of the cache.
 * @return A new cache provider or {@code null} if no cache should be used.
 */
private static CacheProvider newCaffeineCache(final int minCacheSize, final long maxCacheSize) {

    if (maxCacheSize <= 0) {
        return null;
    }

    final Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
            .initialCapacity(minCacheSize)
            .maximumSize(Math.max(minCacheSize, maxCacheSize));

    final CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.setAllowNullValues(false);
    manager.setCaffeine(caffeine);

    return new SpringCacheProvider(manager);
}
 

@Bean(EXPIRE_AFTER_5M)
@Primary
CacheManager cacheManager5m() {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCacheSpecification("maximumSize=100,expireAfterWrite=5m");
    return caffeineCacheManager;
}
 

/**
 * The auto configuration creates the expected beans.
 */
@Test
void expectedBeansExist() {
    this.contextRunner.run(
        context -> {
            // This should be provided by the Spring Boot starter after @EnableCaching is applied
            Assertions.assertThat(context).hasSingleBean(CacheManager.class);
            Assertions.assertThat(context).hasSingleBean(CaffeineCacheManager.class);
        }
    );
}
 

@Bean
public CacheManager cacheManager(Caffeine caffeine) {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.getCache("addresses");
    caffeineCacheManager.setCaffeine(caffeine);
    return caffeineCacheManager;
}
 

@Test
void shouldNotInstantiateCaffeineLoadBalancerCacheIfDisabled() {
	ApplicationContextRunner contextRunner = baseApplicationRunner()
			.withPropertyValues("spring.cloud.loadbalancer.cache.enabled=false")
			.withUserConfiguration(TestConfiguration.class);

	contextRunner.run(context -> {
		assertThat(context.getBeansOfType(CacheManager.class)).hasSize(1);
		assertThat(context.getBean("cacheManager"))
				.isInstanceOf(CaffeineCacheManager.class);
		assertThat(((CacheManager) context.getBean("cacheManager")).getCacheNames())
				.isEmpty();
	});
}
 

@Test
void caffeineLoadBalancerCacheShouldNotOverrideCacheTypeSetting() {
	ApplicationContextRunner contextRunner = baseApplicationRunner()
			.withUserConfiguration(TestConfiguration.class)
			.withPropertyValues("spring.cache.type=none");

	contextRunner.run(context -> {
		assertThat(context.getBeansOfType(CacheManager.class)).hasSize(2);
		assertThat(context.getBean("caffeineLoadBalancerCacheManager"))
				.isInstanceOf(CaffeineCacheManager.class);
		assertThat(context.getBeansOfType(CacheManager.class).get("cacheManager"))
				.isInstanceOf(NoOpCacheManager.class);

	});
}
 

@Bean
public CacheManager honorRollsCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(1, TimeUnit.HOURS)
      .maximumSize(100);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("listHonorRoll");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

/**
 * short life client app user cache (the cache is Optional<ClientAppUser>), so this is not
 * distribute-able
 *
 * @see {@link io.kaif.model.clientapp.ClientAppDao#findClientAppUserWithCache}
 */
@Bean
public CacheManager findClientAppUserCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(1, TimeUnit.MINUTES)
      .maximumSize(1000);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("findClientAppUser");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

/**
 * administrators cache, refresh every one minutes. no need to distribute if we have multiple
 * web servers (user just not see new administrators)
 */
@Bean
public CacheManager listAdministratorsCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(1, TimeUnit.MINUTES)
      .maximumSize(1000);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("listAdministrators");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

/**
 * hot zones cache, refresh every one hour. no need to distribute if we have multiple web servers
 *
 * @see {@link io.kaif.model.article.ArticleDao#listHotZonesWithCache(int, java.time.Instant)}
 */
@Bean
public CacheManager listHotZonesCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(1, TimeUnit.HOURS)
      .maximumSize(1000);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("listHotZones");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

@Bean
public CacheManager articleCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(10, TimeUnit.MINUTES)
      .maximumSize(2000);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("Article");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

@Bean
public CacheManager zoneInfoCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(10, TimeUnit.MINUTES)
      .maximumSize(2000);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("ZoneInfo");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

@Bean
public CacheManager rssHotArticlesCacheManager() {
  Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
      .expireAfterWrite(4, TimeUnit.HOURS)
      .maximumSize(100);
  CaffeineCacheManager cacheManager = new CaffeineCacheManager("rssHotArticles");
  cacheManager.setCaffeine(cacheBuilder);
  return cacheManager;
}
 

/**
 * @return the direct cache manager to access without tenant aware
 *         check, cause in sometimes it's necessary to access the cache
 *         directly without having the current tenant, e.g. initial
 *         creation of tenant
 */
@Bean(name = "directCacheManager")
@ConditionalOnMissingBean(name = "directCacheManager")
public CacheManager directCacheManager(final CacheProperties cacheProperties) {
    final CaffeineCacheManager cacheManager = new CaffeineCacheManager();

    if (cacheProperties.getTtl() > 0) {
        final Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder()
                .expireAfterWrite(cacheProperties.getTtl(), cacheProperties.getTtlUnit());
        cacheManager.setCaffeine(cacheBuilder);
    }

    return cacheManager;
}
 

/**
 * @param tenantAware
 *            to get current tenant
 * @param size
 *            the maximum size of the cache
 */
public RolloutStatusCache(final TenantAware tenantAware, final long size) {
    this.tenantAware = tenantAware;

    final Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder().maximumSize(size);
    final CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCaffeine(cacheBuilder);

    this.cacheManager = new TenantAwareCacheManager(caffeineCacheManager, tenantAware);
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean(ENTITY_CACHE)
CacheManager entityCache(GrpcProperties grpcProperties) {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCacheSpecification("maximumSize=" + grpcProperties.getEntityCacheSize());
    return caffeineCacheManager;
}
 

@Bean
CacheManager cacheManager() {
    // provide a cache manager to test caching
    return new CaffeineCacheManager();
}
 

@Bean
public CacheManagerCustomizer<CaffeineCacheManager> cacheManagerCustomizer() {
    return cacheManager -> cacheManager.setAllowNullValues(true);
}
 

@Bean(EXPIRE_AFTER_30M)
CacheManager cacheManager30m() {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCacheSpecification("maximumSize=10000,expireAfterWrite=30m");
    return caffeineCacheManager;
}
 

@Bean(TINY_LRU_CACHE)
CacheManager tinyLruCache() {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCacheSpecification("maximumSize=100");
    return caffeineCacheManager;
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}
 

@Bean
@Qualifier("caffeineCacheManager")
public CaffeineCacheManager caffeineCacheManager() {
    return new CaffeineCacheManager();
}