@CacheEvict for invalidation in Spring Boot - Step-by-Step Execution

Concept Flow - @CacheEvict for invalidation

Method Called

↓

Check @CacheEvict

↓

Evict Cache Entry

↓

Execute Method Body

↓

Return Result

↓

Cache Updated Without Evicted Entry

When a method with @CacheEvict runs, it first removes specified cache entries, then runs the method, ensuring stale data is cleared.

Execution Sample

Spring Boot

@CacheEvict(value = "books", key = "#id", beforeInvocation = true)
public void deleteBook(Long id) {
  bookRepository.deleteById(id);
}

This method deletes a book by id and removes its cache entry from 'books' cache.

Execution Table

Step	Action	Cache State Before	Cache Eviction	Method Execution	Cache State After
1	Method deleteBook(42) called	{"books": {"42": "Book A", "43": "Book B"}}	Evict key 42 from 'books'	Delete book with id 42 from DB	{"books": {"43": "Book B"}}
2	Method returns	{"books": {"43": "Book B"}}	No eviction	No action	{"books": {"43": "Book B"}}

💡 Method completes after evicting cache key 42 and deleting book 42 from database

Variable Tracker

Variable	Start	After Step 1	After Step 2
cache.books	{"42": "Book A", "43": "Book B"}	{"43": "Book B"}	{"43": "Book B"}
method.id	N/A	42	42

Key Moments - 2 Insights

Why does the cache entry get removed before the method runs?

Because @CacheEvict removes the cache entry first to avoid stale data if the method changes data, as shown in execution_table step 1.

What happens if the cache key does not exist when @CacheEvict runs?

No error occurs; eviction silently skips missing keys, so cache state remains unchanged except for confirmed evictions (see execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what is the cache state after step 1?

A {}

B {"books": {"43": "Book B"}}

C {"books": {"42": "Book A", "43": "Book B"}}

D {"books": {"42": "Book A"}}

💡 Hint

Check the 'Cache State After' column in row for step 1.

At which step does the method delete the book from the database?

A Step 1

B Step 2

C Before Step 1

D After Step 2

💡 Hint

Look at the 'Method Execution' column in execution_table.

If the @CacheEvict annotation was removed, what would happen to the cache after method execution?

A Cache would be empty

B Cache would remove all entries

C Cache would still contain the old entry for key 42

D Cache would add a new entry for key 42

💡 Hint

Refer to the cache eviction step in execution_table step 1.

Concept Snapshot

@CacheEvict removes cache entries before method runs.
Use value to specify cache name.
Use key to specify which entry to evict.
Prevents stale data after data changes.
Eviction happens even if method fails.

Full Transcript

When a method annotated with @CacheEvict is called, Spring first removes the specified cache entry. This prevents stale data from remaining if the method changes data. After eviction, the method body executes, such as deleting a record from the database. Finally, the method returns, and the cache no longer contains the evicted entry. If the cache key does not exist, eviction silently skips it without error. This ensures cache consistency with the data source.

Practice

1. What is the primary purpose of the @CacheEvict annotation in Spring Boot?

easy

A. To remove or invalidate cache entries after data changes

B. To add new entries to the cache

C. To configure cache storage location

D. To read data from the cache without modification

Solution

1. Step 1: Understand cache behavior

   Cache stores data to speed up repeated access, but stale data can cause issues.

2. Step 2: Role of @CacheEvict

   @CacheEvict is used to remove outdated cache entries after data changes to keep cache fresh.

3. Final Answer:

   To remove or invalidate cache entries after data changes -> Option A

4. Quick Check:

   @CacheEvict removes cache entries [OK]

Hint: Remember: @CacheEvict clears cache after updates [OK]

Common Mistakes:

• Confusing @CacheEvict with @CachePut or @Cacheable
• Thinking it adds cache entries instead of removing
• Assuming it configures cache storage

2. Which of the following is the correct way to use @CacheEvict to clear a cache named "users" after a method executes?

easy

A. @CacheEvict(cacheNames = "users", allEntries = true)

B. @CacheEvict(cacheName = "users", clearAll = true)

C. @CacheEvict(value = "users", removeAll = true)

D. @CacheEvict(cache = "users", evictAll = true)

Solution

1. Step 1: Identify correct attribute names

   The correct attribute to specify cache names is cacheNames or value. To clear all entries, use allEntries = true.

2. Step 2: Match correct syntax

   @CacheEvict(cacheNames = "users", allEntries = true) uses @CacheEvict(cacheNames = "users", allEntries = true), which is valid syntax.

3. Final Answer:

   @CacheEvict(cacheNames = "users", allEntries = true) -> Option A

4. Quick Check:

   cacheNames + allEntries = true [OK]

Hint: Use cacheNames and allEntries=true to clear all cache keys [OK]

Common Mistakes:

• Using wrong attribute names like cacheName or cache
• Confusing allEntries with clearAll or removeAll
• Missing quotes around cache name

3. Consider this method in a Spring Boot service:

@CacheEvict(cacheNames = "products", key = "#id")
public void deleteProduct(Long id) {
    productRepository.deleteById(id);
}

What happens when deleteProduct(5L) is called?

medium

A. All entries in 'products' cache are removed

B. The cache entry with key 5 in 'products' cache is removed

C. A new cache entry with key 5 is added

D. The method throws a runtime error due to missing key

Solution

1. Step 1: Analyze @CacheEvict usage

   The annotation specifies cacheNames = "products" and key = "#id", so it targets the cache entry with the given id.

2. Step 2: Effect of calling deleteProduct(5L)

   Calling with id 5 removes the cache entry with key 5 from the 'products' cache.

3. Final Answer:

   The cache entry with key 5 in 'products' cache is removed -> Option B

4. Quick Check:

   @CacheEvict with key removes specific cache entry [OK]

Hint: Key in @CacheEvict targets specific cache entry [OK]

Common Mistakes:

• Assuming all cache entries are removed without allEntries=true
• Thinking it adds cache entries instead of removing
• Believing missing key causes runtime error

4. Given this method:

@CacheEvict(cacheNames = "orders", key = "#order.id")
public void cancelOrder(Order order) {
    orderRepository.delete(order);
}

Why might the cache eviction not work as expected?

medium

A. The key expression should be #orderId instead of #order.id

B. The method parameter 'order' is not accessible in SpEL key expression

C. The key expression #order.id requires the 'order' object to be non-null and have a valid id

D. @CacheEvict cannot use complex key expressions

Solution

1. Step 1: Understand SpEL key expression

   The key expression #order.id accesses the id property of the 'order' parameter. This requires 'order' to be non-null and have a valid id.

2. Step 2: Identify why eviction might fail

   If 'order' is null or its id is null, the cache key cannot be resolved, so eviction won't work as expected.

3. Final Answer:

   The key expression #order.id requires the 'order' object to be non-null and have a valid id -> Option C

4. Quick Check:

   SpEL key needs valid object and property [OK]

Hint: Ensure key objects are non-null with valid properties [OK]

Common Mistakes:

• Assuming key expressions cannot use object properties
• Using wrong parameter names in key expression
• Believing @CacheEvict cannot handle complex keys

5. You have a Spring Boot service with two caches: "users" and "sessions". You want to clear all entries in "sessions" cache whenever a user is deleted, but keep "users" cache intact. Which @CacheEvict usage correctly achieves this in the deleteUser method?

public void deleteUser(Long userId) {
    userRepository.deleteById(userId);
    // cache eviction here
}

hard

A. @CacheEvict(cacheNames = "sessions", key = "#userId") on deleteUser method

B. @CacheEvict(cacheNames = {"users", "sessions"}, allEntries = true) on deleteUser method

C. @CacheEvict(cacheNames = "users", key = "#userId") on deleteUser method

D. @CacheEvict(cacheNames = "sessions", allEntries = true) on deleteUser method

Solution

1. Step 1: Understand requirement

   We want to clear all entries in "sessions" cache only, not affect "users" cache.

2. Step 2: Analyze options

   @CacheEvict(cacheNames = "sessions", allEntries = true) on deleteUser method clears all entries in "sessions" cache, matching requirement. @CacheEvict(cacheNames = {"users", "sessions"}, allEntries = true) on deleteUser method clears both caches, which is incorrect. @CacheEvict(cacheNames = "users", key = "#userId") on deleteUser method clears only one user key in "users" cache, not sessions. @CacheEvict(cacheNames = "sessions", key = "#userId") on deleteUser method clears one key in "sessions" cache, not all.

3. Final Answer:

   @CacheEvict(cacheNames = "sessions", allEntries = true) on deleteUser method -> Option D

4. Quick Check:

   allEntries=true clears entire cache [OK]

Hint: Use allEntries=true on target cache to clear all keys [OK]

Common Mistakes:

• Clearing wrong cache or multiple caches unintentionally
• Using key instead of allEntries to clear entire cache
• Assuming deleting user clears user cache automatically