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

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
}

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
}

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

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.

Practice

1. What is the main purpose of a cache key in Spring Boot caching?

easy

A. To define the cache size limit

B. To store the actual data in the cache

C. To uniquely identify cached data for quick retrieval

D. To clear the cache automatically

Solution

1. Step 1: Understand cache key role

   A cache key uniquely identifies the cached data so the system can find it quickly without confusion.

2. Step 2: Differentiate from other cache functions

   Cache keys do not store data or control cache size; they only act as unique identifiers.

3. Final Answer:

   To uniquely identify cached data for quick retrieval -> Option C

4. Quick Check:

   Cache key = unique identifier [OK]

Hint: Cache keys uniquely identify data to find it fast [OK]

Common Mistakes:

• Thinking cache keys store data
• Confusing keys with cache size settings
• Assuming keys clear cache automatically

2. Which of the following is the correct way to specify a cache key using Spring Expression Language (SpEL) in the @Cacheable annotation?

easy

A. @Cacheable(key = "#user.id")

B. @Cacheable(key = user.id)

C. @Cacheable(key = "user.id")

D. @Cacheable(key = #user.id)

Solution

1. Step 1: Recognize SpEL syntax in @Cacheable

   SpEL expressions must be inside double quotes and start with # to reference method parameters.

2. Step 2: Check each option

   @Cacheable(key = "#user.id") correctly uses "#user.id" as a string with # for SpEL. @Cacheable(key = user.id) misses quotes, the option with "user.id" misses #, @Cacheable(key = #user.id) misses quotes.

3. Final Answer:

   @Cacheable(key = "#user.id") -> Option A

4. Quick Check:

   SpEL key syntax = quoted string with # [OK]

Hint: SpEL keys need quotes and # before variable [OK]

Common Mistakes:

• Omitting quotes around SpEL expression
• Forgetting # before parameter name
• Using plain variable without SpEL syntax

3. Given the method annotated as @Cacheable(value = "users", key = "#id"), what will be the cache key when calling getUser(42)?

medium

A. "id"

B. 42

C. "#id"

D. null

Solution

1. Step 1: Understand key expression #id

   The key uses SpEL #id which means the method parameter named id's value is used as the key.

2. Step 2: Substitute method call parameter

   Calling getUser(42) means id = 42, so the cache key is 42 (an integer).

3. Final Answer:

   42 -> Option B

4. Quick Check:

   Key = parameter value 42 [OK]

Hint: Cache key #param uses actual parameter value [OK]

Common Mistakes:

• Using the string '#id' instead of parameter value
• Confusing key with parameter name only
• Assuming null key if not specified

4. Identify the error in this cache key definition: @Cacheable(value = "items", key = "#item.id + #item.name")

medium

A. SpEL expressions cannot concatenate strings with + operator

B. Missing parentheses around the expression

C. The key must be a constant string, not an expression

D. Using + operator without converting to string may cause wrong key

Solution

1. Step 1: Analyze SpEL expression with + operator

   In SpEL, + can add numbers or concatenate strings. If item.id is numeric, adding to item.name (string) may cause type issues.

2. Step 2: Understand type conversion in keys

   Without explicit string conversion, adding number + string may produce unexpected keys or errors.

3. Final Answer:

   Using + operator without converting to string may cause wrong key -> Option D

4. Quick Check:

   Type mismatch in key expression = error [OK]

Hint: Convert all parts to string before concatenation in keys [OK]

Common Mistakes:

• Assuming + always concatenates strings
• Not converting numeric parts to string explicitly
• Thinking key must be constant string only

5. You want to cache results of a method that takes two parameters: userId (Long) and filter (String). Which cache key strategy ensures unique keys for each combination?

hard

A. Use key = "T(java.util.Objects).hash(#userId, #filter)"

B. Use key = "#userId + #filter" without conversion

C. Use key = "#userId" only

D. Use key = "#filter" only

Solution

1. Step 1: Understand need for unique keys per parameter combo

   Using only one parameter as key risks collisions when other parameter changes.

2. Step 2: Evaluate options for combining parameters

   Use key = "#userId + #filter" without explicit conversion risks type issues. Use key = "T(java.util.Objects).hash(#userId, #filter)" uses Java's Objects.hash to combine both safely. Using only one parameter causes collisions.

3. Final Answer:

   Use key = "T(java.util.Objects).hash(#userId, #filter)" -> Option A

4. Quick Check:

   Combine keys safely with Objects.hash [OK]

Hint: Use Objects.hash to combine multiple parameters safely [OK]

Common Mistakes:

• Concatenating keys without type safety
• Using only one parameter as key causing collisions
• Ignoring proper SpEL syntax for static method calls