Cache key strategies in Spring Boot - Mini Project: Build & Apply

Cache Key Strategies in Spring Boot

📖 Scenario: You are building a Spring Boot application that fetches user data from a database. To improve performance, you want to cache user information. Proper cache key strategies help avoid cache collisions and ensure correct data retrieval.

🎯 Goal: Create a Spring Boot service that caches user data using different cache key strategies. You will start by setting up user data, then configure a cache key prefix, apply caching with a custom key, and finally complete the caching setup with a cache manager bean.

📋 What You'll Learn

Create a Map called userData with exact user IDs and names

Add a String variable cacheKeyPrefix with value "userCache:"

Create a method getUserById annotated with @Cacheable using a custom key combining cacheKeyPrefix and userId

Define a CacheManager bean to enable caching in the application

💡 Why This Matters

🌍 Real World

Caching user data in web applications improves response time and reduces database load by storing frequently accessed data in memory.

💼 Career

Understanding cache key strategies and Spring Boot caching is essential for backend developers to optimize application performance and scalability.

1

Data Setup: Create user data map

Create a Map called userData with these exact entries: "101" : "Alice", "102" : "Bob", "103" : "Charlie".

Spring Boot

// Your code here

Need a hint?

Use Map.of to create an immutable map with the exact user IDs and names.

2

Configuration: Add cache key prefix

Add a String variable called cacheKeyPrefix and set it to "userCache:" inside the UserService class.

Spring Boot

import java.util.Map;
import java.util.HashMap;

public class UserService {
    private Map userData = Map.of(
        "101", "Alice",
        "102", "Bob",
        "103", "Charlie"
    );

    // Add cache key prefix here
}

Need a hint?

Declare a private String variable named cacheKeyPrefix and assign it the value "userCache:".

3

Core Logic: Add caching with custom cache key

Create a method getUserById that takes a String parameter userId and returns the user name from userData. Annotate this method with @Cacheable using the cache name "users" and a key expression combining cacheKeyPrefix and userId like "#root.target.cacheKeyPrefix + #userId".

Spring Boot

import java.util.Map;
import java.util.HashMap;
import org.springframework.cache.annotation.Cacheable;

public class UserService {
    private Map userData = Map.of(
        "101", "Alice",
        "102", "Bob",
        "103", "Charlie"
    );

    private String cacheKeyPrefix = "userCache:";

    // Add getUserById method with @Cacheable and custom key
}

Need a hint?

Use @Cacheable with value="users" and a key expression that concatenates cacheKeyPrefix and userId.

4

Completion: Define CacheManager bean

In a configuration class, define a CacheManager bean method called cacheManager that returns a ConcurrentMapCacheManager with cache name "users". Annotate the class with @Configuration and the method with @Bean.

Spring Boot

import java.util.Map;
import java.util.HashMap;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;

@Service
public class UserService {
    private Map userData = Map.of(
        "101", "Alice",
        "102", "Bob",
        "103", "Charlie"
    );

    private String cacheKeyPrefix = "userCache:";

    @Cacheable(value = "users", key = "#root.target.cacheKeyPrefix + #userId")
    public String getUserById(String userId) {
        return userData.get(userId);
    }
}

// Add CacheManager bean configuration below

Need a hint?

Create a configuration class annotated with @Configuration. Inside it, define a cacheManager method annotated with @Bean that returns a ConcurrentMapCacheManager for the "users" cache.