Cache configuration in Spring Boot

Introduction

Cache configuration helps your app remember data so it can work faster next time. It saves time by not repeating slow tasks.

When your app fetches data from a database many times and you want to speed it up.

When you call a slow external service and want to avoid calling it repeatedly.

When you want to reduce load on your server by storing results temporarily.

When you want to improve user experience by showing data faster.

When you want to control how long data stays saved before refreshing.

Syntax

Spring Boot

@EnableCaching
@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("items");
    }
}

@EnableCaching turns on caching in your Spring Boot app.

CacheManager defines where and how cache is stored.

Examples

This example creates caches named 'books' and 'authors' using simple in-memory storage.

Spring Boot

@EnableCaching
@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("books", "authors");
    }
}

This example shows another way to create a cache manager with a cache named 'users'.

Spring Boot

@EnableCaching
@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager manager = new SimpleCacheManager();
        manager.setCaches(List.of(new ConcurrentMapCache("users")));
        return manager;
    }
}

Sample Program

This program sets up a cache named 'greetings'. The GreetingService method getGreeting simulates a slow call by waiting 2 seconds. The first call caches the result. The second call returns the cached greeting immediately, making it faster.

Spring Boot

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import java.util.List;

@EnableCaching
@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("greetings");
    }
}

@Service
class GreetingService {

    @Cacheable("greetings")
    public String getGreeting(String name) {
        try {
            Thread.sleep(2000); // simulate slow method
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Hello, " + name + "!";
    }
}

// Usage example (e.g., in a Spring context with @Autowired GreetingService service):
// System.out.println(service.getGreeting("Alice")); // takes 2 seconds first time
// System.out.println(service.getGreeting("Alice")); // returns instantly from cache

Important Notes

Cache names must match between configuration and @Cacheable annotations.

Use caching only for data that does not change often or can be stale briefly.

Spring Boot supports many cache types like Redis, Ehcache, and simple memory caches.

Summary

Cache configuration speeds up apps by storing data temporarily.

Use @EnableCaching and define a CacheManager bean to set up caching.

Mark methods with @Cacheable to save their results automatically.

Practice

1. What is the primary purpose of using cache configuration in a Spring Boot application?

easy

A. To temporarily store data and speed up application performance

B. To permanently save data to the database

C. To encrypt sensitive data before sending it

D. To manage user authentication and authorization

Solution

1. Step 1: Understand caching concept

   Caching stores data temporarily to avoid repeated processing or fetching.

2. Step 2: Identify caching benefit in Spring Boot

   It speeds up the app by reusing stored data instead of recalculating or fetching again.

3. Final Answer:

   To temporarily store data and speed up application performance -> Option A

4. Quick Check:

   Cache = Temporary storage for speed [OK]

Hint: Cache means temporary storage to speed up apps [OK]

Common Mistakes:

• Confusing cache with permanent database storage
• Thinking cache encrypts data
• Mixing cache with security features

2. Which annotation is used to enable caching support in a Spring Boot application?

easy

A. @EnableCaching

B. @Cacheable

C. @CacheConfig

D. @CachePut

Solution

1. Step 1: Recall Spring Boot caching setup

   To activate caching, Spring Boot requires a special annotation on a configuration class.

2. Step 2: Identify the correct annotation

   @EnableCaching enables the caching mechanism globally in the app.

3. Final Answer:

   @EnableCaching -> Option A

4. Quick Check:

   @EnableCaching activates caching [OK]

Hint: Enable caching with @EnableCaching annotation [OK]

Common Mistakes:

• Using @Cacheable to enable caching (it marks methods, not enable)
• Confusing @CachePut with enabling caching
• Thinking @CacheConfig enables caching globally

3. Given the code below, what will be the output when getUser(1) is called twice?

@Cacheable("users")
public User getUser(int id) {
    System.out.println("Fetching user from DB");
    return new User(id, "Name" + id);
}

medium

A. Fetching user from DB printed twice, two User objects returned

B. No output printed, both calls return null

C. Fetching user from DB printed once, but both calls create new User

D. Fetching user from DB printed once, second call returns cached User

Solution

1. Step 1: Understand @Cacheable behavior

   The first call runs the method and caches the result; subsequent calls return cached data.

2. Step 2: Analyze output for two calls

   "Fetching user from DB" prints only once on first call; second call uses cache, no print.

3. Final Answer:

   Fetching user from DB printed once, second call returns cached User -> Option D

4. Quick Check:

   @Cacheable caches after first call [OK]

Hint: First call runs method, next calls use cache [OK]

Common Mistakes:

• Assuming method runs every time ignoring cache
• Thinking cache returns null if not found
• Confusing @Cacheable with @CachePut behavior

4. Identify the error in this cache configuration snippet:

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new CacheManager();
    }
}

medium

A. Missing @Cacheable annotation on methods

B. CacheManager is an interface and cannot be instantiated directly

C. Missing @EnableCaching annotation

D. CacheManager bean method should be static

Solution

1. Step 1: Check CacheManager instantiation

   CacheManager is an interface; you cannot create it with new CacheManager().

2. Step 2: Correct way to create CacheManager bean

   You must return a concrete implementation like ConcurrentMapCacheManager.

3. Final Answer:

   CacheManager is an interface and cannot be instantiated directly -> Option B

4. Quick Check:

   CacheManager interface needs implementation [OK]

Hint: CacheManager is interface; use implementation class [OK]

Common Mistakes:

• Trying to instantiate interface directly
• Forgetting to add @EnableCaching
• Thinking @Cacheable is needed on config class

5. You want to configure a cache in Spring Boot that stores user data and expires entries after 10 minutes. Which approach correctly combines cache configuration and expiration?

hard

A. Use @EnableCaching and define a ConcurrentMapCacheManager bean with TTL set to 10 minutes

B. Use @CachePut and manually remove cache entries after 10 minutes

C. Use @EnableCaching and configure a CaffeineCacheManager with expiry policy of 10 minutes

D. Use @Cacheable with a parameter to set expiration time to 10 minutes

Solution

1. Step 1: Understand cache expiration support

   ConcurrentMapCacheManager does not support TTL (time to live) expiration by default.

2. Step 2: Identify cache manager with TTL support

   CaffeineCacheManager supports expiration policies like 10-minute TTL.

3. Step 3: Evaluate options

   @Cacheable does not accept expiration parameters; @CachePut updates cache but does not manage expiration automatically.

4. Final Answer:

   Use @EnableCaching and configure a CaffeineCacheManager with expiry policy of 10 minutes -> Option C

5. Quick Check:

   CaffeineCacheManager supports TTL expiration [OK]

Hint: Use CaffeineCacheManager for TTL expiration [OK]

Common Mistakes:

• Assuming ConcurrentMapCacheManager supports TTL
• Trying to set expiration via @Cacheable annotation
• Using @CachePut to handle expiration manually