CODEWITHSUNDEEP
javaspringcachingkubernetescaffeine
OLY
OLY

Reputation: 75

Define multiple caches configurations with Spring and Caffeine

I need to use several caches in my service for different uses. I'm looking for a way to separate their configurations like maximumSize and expireAfterWrite. I'm using Spring and Kubernetes, and in the deploy.yaml I have this:

spring:
  main:
    allow-bean-definition-overriding: true
  cache:
    type: CAFFEINE
    cache-names: cacheA, cacheB
    caffeine:
      spec: expireAfterWrite=1h,maximumSize=2000
  output:
    ansi:
      enabled: never

I want to create a new cache, cacheC, which will have a different configurations.

How can I do that? Thanks!

Upvotes: 3

Views: 7445

Answers (2)

SMEW Technology
SMEW Technology

Reputation: 1051

Best solution for you.

@Configuration
@EnableCaching
public class CacheConfig {
    @Value("${cache.cache-names.otpCache}")
    String otpCacheName;
    @Value("${cache.cache-names.tokenCache}")
    String tokenCacheName;
    @Value("${cache.ttl.otpCache}")
    int otpCacheTTL;
    @Value("${cache.ttl.tokenCache}")
    int tokenCacheTTL;


    @Bean("otp-cache")
    public CacheManager tokenCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager(otpCacheName);
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(otpCacheTTL, TimeUnit.SECONDS));
        return cacheManager;
    }

    @Bean("token-cache")
    public CacheManager otpCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager(tokenCacheName);
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(tokenCacheTTL, TimeUnit.HOURS));
        return cacheManager;
    }
}

Upvotes: 1

Santiago Medina
Santiago Medina

Reputation: 579

You can declare many cache configurations programmatically instead of using yaml.

Something like this:

@Configuration
@EnableCaching
public class CacheConfig {

    public static final String CACHE_A = "cacheA";
    public static final String CACHE_B = "cacheB";
    public static final String CACHE_C = "cacheC";

    @Bean
    public CacheManager cacheManagerTicker(Ticker ticker) {
       
       List<Cache> caches = new ArrayList<>();
       
       // Cache A
       caches.add(this.buildCache(CACHE_A, ticker, 2000L, 1L, TimeUnit.HOURS));
       
       // Cache B
       caches.add(this.buildCache(CACHE_B, ticker, 2000L, 1L, TimeUnit.HOURS));
       
       // Cache C
       caches.add(this.buildCache(CACHE_C, ticker, 3500L, 15L, TimeUnit.MINUTES));
       
       SimpleCacheManager cacheManager = new SimpleCacheManager();
       cacheManager.setCaches(caches);
       return cacheManager;
    }
    
    private CaffeineCache buildCache(String cacheName, Ticker ticker, Long maxSize, Long ttl, TimeUnit ttlUnit){
    
        Caffeine<Object, Object> cacheBuilder = Caffeine.newBuilder();

        // TTL
        if (ttl != null && ttl > 0 && ttlUnit != null){
            cacheBuilder.expireAfterWrite(ttl, ttlUnit);
        }
        
        // Max size
        if (maxSize != null && maxSize > 0){
            cacheBuilder.maximumSize(maxSize);
        }
        
        // Ticker
        cacheBuilder.ticker(ticker);
        
        return new CaffeineCache(cacheName, cacheBuilder.build());
    }
    
    @Bean
    public Ticker ticker() {
        return Ticker.systemTicker();
    }
    
}

Upvotes: 5

Related Questions