Cache key strategies in Spring Boot - Step-by-Step Execution

Concept Flow - Cache key strategies

Start: Method call

↓

Generate Cache Key

↓

Check Cache for Key

↓

Return Cached

↓

Return Result

↓

End

This flow shows how a cache key is generated and used to check cache before method execution, returning cached data if available or storing new data after execution.

Execution Sample

Spring Boot

@Cacheable(value = "users", key = "#userId")
public User getUser(String userId) {
    // fetch user from DB
    return userRepository.findById(userId);
}

This code caches the result of getUser method using userId as the cache key.

Execution Table

Step	Action	Cache Key Generated	Cache Hit?	Method Executed	Cache Updated	Returned Value
1	Call getUser("123")	"123"	No	Yes	Yes	User object for 123
2	Call getUser("123") again	"123"	Yes	No	No	User object for 123
3	Call getUser("456")	"456"	No	Yes	Yes	User object for 456
4	Call getUser(null)	"null"	No	Yes	Yes	User object for null
5	Call getUser("123") again	"123"	Yes	No	No	User object for 123

💡 Execution stops when method calls end; cache keys determine if method runs or cached data returns.

Variable Tracker

Variable	Start	After Call 1	After Call 2	After Call 3	After Call 4	After Call 5
cache	{}	{"123": User123}	{"123": User123}	{"123": User123, "456": User456}	{"123": User123, "456": User456, "null": UserNull}	{"123": User123, "456": User456, "null": UserNull}
cacheKey	N/A	"123"	"123"	"456"	"null"	"123"
methodExecuted	N/A	true	false	true	true	false

Key Moments - 3 Insights

Why does the method not execute on the second call with the same key?

Because the cache key "123" was found in cache (see execution_table step 2), so cached data is returned without running the method.

What happens if the cache key is null or unexpected?

The key "null" is treated as a string key (step 4), so caching still works but be careful to handle null keys properly.

Why is the cache updated only when the method executes?

Cache updates happen after method execution to store fresh results (steps 1, 3, 4). If cache hit occurs, no update is needed.

Visual Quiz - 3 Questions

Look at the execution_table, what is the cache key generated at step 3?

A "123"

B "null"

C "456"

D No key generated

💡 Hint

Check the 'Cache Key Generated' column at step 3 in execution_table.

At which step does the method execute because the cache did not have the key?

A Step 2

B Step 1

C Step 5

D Step 4

💡 Hint

Look at 'Cache Hit?' and 'Method Executed' columns in execution_table.

If the cache key was changed to include method name, how would the cache keys look?

A "getUser:123"

B "123"

C "user:123"

D "method123"

💡 Hint

Think about adding method name prefix to keys for uniqueness.

Concept Snapshot

Cache key strategies in Spring Boot:
- Use @Cacheable with 'key' to define cache keys.
- Cache key uniquely identifies method input.
- On method call, key is generated and cache checked.
- If key found, return cached result.
- If not, execute method and store result with key.
- Handle null keys carefully to avoid collisions.

Full Transcript

This visual execution shows how Spring Boot cache keys work. When a method annotated with @Cacheable is called, a cache key is generated from the method parameters. The cache is checked for this key. If the key exists, the cached result is returned immediately without running the method again. If the key does not exist, the method runs, and its result is stored in the cache with that key. This process repeats for each method call. The cache key must uniquely identify the input to avoid wrong data returns. Null or unexpected keys are treated as strings but should be handled carefully. This strategy improves performance by avoiding repeated expensive method executions.