Spring Boot and Caffeine Cache

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

1. Overview

Caffeine cache is a high-performance cache library for Java. In this short tutorial, we’ll see how to use it with Spring Boot.

2. Dependencies

To get started with Caffeine and Spring Boot, we first add the spring-boot-starter-cache and caffeine dependencies:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
</dependencies>

These import the base Spring caching support, along with the Caffeine library.

3. Configuration

Now we need to configure caching in our Spring Boot application.

First, we create a Caffeine bean. This is the main configuration that will control caching behavior such as expiration, cache size limits, and more:

@Bean
public Caffeine caffeineConfig() {
    return Caffeine.newBuilder().expireAfterWrite(60, TimeUnit.MINUTES);
}

Next, we need to create another bean using the Spring CacheManager interface. Caffeine provides its implementation of this interface, which requires the Caffeine object we created above:

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

Finally, we need to enable caching in Spring Boot using the @EnableCaching annotation. This can be added to any @Configuration class in the application.

4. Examples

With caching enabled and configured to use Caffeine, let’s look at a few examples of how we can use caching in our Spring Boot application.

The primary way to use caching in Spring Boot is with the @Cacheable annotation. This annotation works on any method of a Spring bean (or even the entire class). It instructs the registered cache manager to store the result of the method call in a cache.

A typical usage is inside service classes:

@Service
public class AddressService {
    @Cacheable
    public AddressDTO getAddress(long customerId) {
        // lookup and return result
    }
}

Using the @Cacheable annotation without parameters will force Spring to use default names for both the cache and cache key.

We can override both of these behaviors by adding some parameters to the annotation:

@Service
public class AddressService {
    @Cacheable(value = "address_cache", key = "customerId")
    public AddressDTO getAddress(long customerId) {
        // lookup and return result
    }
}

The example above tells Spring to use a cache named address_cache and the customerId argument for the cache key.

Finally, because the cache manager is itself a Spring bean, we can also autowire it into any other bean and work with it directly:

@Service
public class AddressService {

    @Autowired
    CacheManager cacheManager;

    public AddressDTO getAddress(long customerId) {
        if(cacheManager.containsKey(customerId)) {
            return cacheManager.get(customerId);
        }
        
        // lookup address, cache result, and return it
    }
}