@CacheEvict for invalidation in Spring Boot - Mini Project: Build & Apply

Using @CacheEvict for Cache Invalidation in Spring Boot

📖 Scenario: You are building a simple Spring Boot service that manages user profiles. To improve performance, you cache user data. When a user profile is updated, you need to clear the cached data to keep it fresh.

🎯 Goal: Build a Spring Boot service with a method to cache user profiles and another method to update profiles that uses @CacheEvict to clear the cache for the updated user.

📋 What You'll Learn

Create a simple UserService class with a method getUserById that returns a user name string.

Add a cache configuration to cache the result of getUserById.

Create an updateUserName method that updates the user name and uses @CacheEvict to clear the cache for that user ID.

Ensure the cache is cleared only for the specific user ID when updateUserName is called.

💡 Why This Matters

🌍 Real World

Caching user data improves performance by avoiding repeated database calls. Clearing cache on updates ensures users see fresh data.

💼 Career

Understanding cache invalidation with <code>@CacheEvict</code> is essential for backend developers working with Spring Boot to build efficient and consistent applications.

1

Create UserService with getUserById method

Create a class called UserService with a method getUserById that takes a Long userId parameter and returns a String user name. For now, return the string "User" + userId.

Spring Boot

public class UserService {
    // Your code here
}

Hint

Define a public class UserService. Inside it, create a public method getUserById that returns a string combining "User" and the userId.

2

Enable caching and add @Cacheable to getUserById

Add the @Cacheable annotation to the getUserById method with cache name "users". Also, add the @Service annotation to the UserService class to make it a Spring service.

Spring Boot

@Service
public class UserService {
    @Cacheable("users")
    public String getUserById(Long userId) {
        return "User" + userId;
    }
    // Your code here
}

Hint

Use @Service on the class and @Cacheable("users") on the getUserById method to enable caching.

3

Add updateUserName method with @CacheEvict

Add a method updateUserName that takes Long userId and String newName parameters. Annotate it with @CacheEvict(cacheNames = "users", key = "#userId") to clear the cache for that user ID. Inside the method, simulate updating by returning newName.

Spring Boot

import org.springframework.cache.annotation.CacheEvict;
// Add updateUserName method below

@Service
public class UserService {
    @Cacheable("users")
    public String getUserById(Long userId) {
        return "User" + userId;
    }
    // Your code here
}

Hint

Create updateUserName method annotated with @CacheEvict to clear cache for the given userId.

4

Add @EnableCaching to application configuration

Create a configuration class called CacheConfig annotated with @Configuration and @EnableCaching to enable Spring caching support.

Spring Boot

import org.springframework.context.annotation.Configuration;
import org.springframework.cache.annotation.EnableCaching;

// Your code here

Hint

Create a class CacheConfig with @Configuration and @EnableCaching annotations to activate caching.

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