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.

Practice

1. What is the main purpose of using Redis as a cache provider in a Spring Boot application?

easy

A. To store frequently accessed data in memory for faster retrieval

B. To replace the database completely

C. To handle user authentication

D. To serve static web pages

Solution

1. Step 1: Understand Redis caching role

   Redis stores data in memory, which is much faster than disk storage.

2. Step 2: Identify caching benefit in Spring Boot

   Caching reduces database calls by storing frequently used data temporarily.

3. Final Answer:

   To store frequently accessed data in memory for faster retrieval -> Option A

4. Quick Check:

   Redis cache = fast data access [OK]

Hint: Redis cache speeds up data access by storing in memory [OK]

Common Mistakes:

• Thinking Redis replaces the database
• Confusing caching with authentication
• Assuming Redis serves static files

2. Which annotation is used in Spring Boot to enable caching support when using Redis?

easy

A. @RedisCache

B. @Cacheable

C. @EnableCaching

D. @CacheConfig

Solution

1. Step 1: Identify the annotation to activate caching

   @EnableCaching is used on a configuration class to turn on caching support.

2. Step 2: Differentiate from other annotations

   @Cacheable marks methods to cache results, but does not enable caching globally.

3. Final Answer:

   @EnableCaching -> Option C

4. Quick Check:

   Enable caching = @EnableCaching [OK]

Hint: Use @EnableCaching to activate caching in Spring Boot [OK]

Common Mistakes:

• Confusing @Cacheable with enabling caching
• Using non-existent @RedisCache annotation
• Mistaking @CacheConfig for enabling caching

3. Given the following Spring Boot method with Redis caching:

@Cacheable("books")
public Book findBookById(Long id) {
    System.out.println("Fetching from DB");
    return bookRepository.findById(id).orElse(null);
}

What will be printed if findBookById(1L) is called twice in a row?

medium

A. Fetching from DB

B. No output

C. Fetching from DB
Fetching from DB

D. Error at runtime

Solution

1. Step 1: Understand @Cacheable behavior

   The first call caches the result and prints "Fetching from DB".

2. Step 2: Analyze second call output

   The second call returns cached data without executing method body, so no print.

3. Final Answer:

   Fetching from DB -> Option A

4. Quick Check:

   Cache avoids repeated DB fetch print [OK]

Hint: First call prints, second uses cache silently [OK]

Common Mistakes:

• Expecting print on every call
• Thinking cache disables method
• Assuming runtime error due to caching

4. Consider this Spring Boot Redis cache configuration snippet:

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
    return RedisCacheManager.builder(factory).build();
}

If the Redis server is down, what will happen when the application tries to cache data?

medium

A. Application falls back to file-based cache

B. Application throws a runtime exception and crashes

C. Data is cached in memory without Redis

D. Caching silently fails but application continues

Solution

1. Step 1: Understand RedisCacheManager dependency

   RedisCacheManager requires a running Redis server to store cache data.

2. Step 2: Analyze behavior if Redis is down

   Without Redis, cache operations typically fail silently and the application continues unless explicitly configured to fail.

3. Final Answer:

   Caching silently fails but application continues -> Option D

4. Quick Check:

   Redis down usually does not crash app by default [OK]

Hint: Redis down causes silent cache failure unless handled [OK]

Common Mistakes:

• Assuming fallback to memory cache
• Thinking caching silently fails
• Expecting file-based fallback

5. You want to cache the result of a method that returns a list of users filtered by role. Which is the best way to use Redis caching in Spring Boot to avoid caching empty or null results?

public List<User> getUsersByRole(String role) {
    // fetch users
}

hard

A. Use @CachePut to always update cache

B. Use @Cacheable with condition = "#result != null && !#result.isEmpty()"

C. Manually check and cache inside the method

D. Use @Cacheable without any condition

Solution

1. Step 1: Understand caching empty results issue

   Caching empty or null results wastes cache space and may cause stale data.

2. Step 2: Use @Cacheable condition attribute

   Adding condition "#result != null && !#result.isEmpty()" caches only meaningful results.

3. Final Answer:

   Use @Cacheable with condition = "#result != null && !#result.isEmpty()" -> Option B

4. Quick Check:

   Condition filters empty cache entries [OK]

Hint: Use @Cacheable condition to skip empty results [OK]

Common Mistakes:

• Caching all results including empty lists
• Manually caching inside method instead of annotation
• Using @CachePut which always updates cache