Redis as cache provider in Spring Boot - Step-by-Step Execution

Concept Flow - Redis as cache provider

Start Application

↓

Check Cache for Key

↓

Return Cached

↓

Return Data

↓

End Request

The app first looks in Redis cache for data. If found, it returns cached data. If not, it fetches from database, stores it in Redis, then returns it.

Execution Sample

Spring Boot

1. @Cacheable("users")
2. public User getUserById(Long id) {
3.   // Check Redis cache
4.   // If miss, fetch from DB
5.   // Store in Redis
6.   return user;
}

This method tries to get a user by ID from Redis cache, if missing it fetches from DB and caches the result.

Execution Table

Step	Action	Cache Check Result	DB Fetch	Cache Store	Return Value
1	Call getUserById(5)	Check Redis for key 'users::5' - No data found	N/A	N/A	N/A
2	Cache miss detected	Miss	Fetch user with ID 5 from DB	Store user in Redis with key 'users::5'	N/A
3	Return user data	N/A	N/A	N/A	User object with ID 5
4	Call getUserById(5) again	Check Redis for key 'users::5' - Data found	N/A	N/A	N/A
5	Return cached user	Hit	No DB fetch	No store	User object with ID 5

💡 Execution stops after returning user data from cache or DB.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
cacheKey	null	'users::5'	'users::5'	'users::5'	'users::5'	'users::5'
cacheData	null	null	null	User(id=5)	User(id=5)	User(id=5)
dbData	null	null	User(id=5)	User(id=5)	User(id=5)	User(id=5)

Key Moments - 2 Insights

Why does the method fetch from the database even though we want to use Redis?

Because the cache is empty at first (cache miss), so the method must fetch data from the database and then store it in Redis. See execution_table row 2.

What happens when the same user ID is requested again?

The method finds the data in Redis cache (cache hit) and returns it directly without querying the database. See execution_table rows 4 and 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the cache check result at step 2?

A Miss

B Hit

C No check

D Error

💡 Hint

Check the 'Cache Check Result' column at step 2 in the execution_table.

At which step does the user data get stored in Redis cache?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Cache Store' column in the execution_table to find when data is stored.

If the cache already has the user data, what changes in the execution flow?

A Cache store happens again

B Method returns null

C Database fetch is skipped

D Cache is cleared

💡 Hint

Refer to execution_table steps 4 and 5 where cache hit avoids DB fetch.

Concept Snapshot

Use @Cacheable annotation on methods to enable Redis caching.
On method call, Spring checks Redis for cached data.
If data exists (cache hit), it returns cached data immediately.
If not (cache miss), method runs, result is stored in Redis.
This speeds up repeated data access and reduces DB load.

Full Transcript

This visual trace shows how Redis acts as a cache provider in a Spring Boot app. When the method getUserById is called, it first checks Redis cache for the user data. If the data is missing, it fetches from the database, stores the result in Redis, then returns it. On subsequent calls with the same ID, the method finds the data in Redis and returns it directly without querying the database. Variables like cacheKey, cacheData, and dbData change as the method progresses. Key moments include understanding cache miss vs hit and when data is stored. The quizzes test knowledge of cache checks, storage timing, and flow changes on cache hits.