@CachePut for updating cache in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a method annotated with @CachePut is called?

Consider a Spring Boot method annotated with @CachePut. What is the behavior when this method is executed?

A The method executes but does not update the cache.

B The method does not execute; the cached value is returned directly.

C The cache is cleared before the method executes.

D The method executes and updates the cache with the returned value without skipping the method execution.

💡 Hint

Think about whether the method runs or if the cache is just read.

@CachePut always runs the method and then updates the cache with the new result. It does not skip method execution like @Cacheable.

📝 Syntax

intermediate

Which @CachePut annotation syntax correctly updates cache named 'users' with key 'user.id'?

Choose the correct @CachePut annotation syntax to update the cache named users using the id property of the user parameter as the key.

A @CachePut(value = "users", key = "user.id")

B @CachePut(value = "users", key = "#user.id")

C @CachePut(cacheNames = "users", key = "user.id")

D @CachePut(cacheNames = "users", key = "#user")

💡 Hint

Remember to use SpEL (Spring Expression Language) syntax for keys.

The key must be a SpEL expression starting with # to access method parameters. Option B correctly uses #user.id.

🔧 Debug

advanced

Why does the cache not update after calling a @CachePut method?

Given this method:

  @CachePut(value = "products", key = "#product.id")
  public Product updateProduct(Product product) {
    productRepository.save(product);
    return product;
  }

Why might the cache not update after calling updateProduct?

A The method is called from within the same class, so Spring proxy does not intercept and update cache.

B The <code>productRepository.save(product)</code> does not update the database, so cache update is skipped.

C The method returns the same product instance without changes, so cache sees no update.

D The cache name 'products' is invalid and causes silent failure.

💡 Hint

Think about how Spring AOP proxies work with self-invocation.

Spring cache annotations work via proxies. If the method is called from the same class (self-invocation), the proxy is bypassed and caching annotations are not applied.

❓ state_output

advanced

What is the cache content after calling updateUser twice with different data?

Given this method:

  @CachePut(value = "users", key = "#user.id")
  public User updateUser(User user) {
    return user;
  }

And these calls:

  updateUser(new User(1, "Alice"));
  updateUser(new User(1, "Bob"));

What is the cached value for key 1?

A User object with id=1 and name='Bob'

B User object with id=1 and name='Alice'

C Cache is empty because @CachePut does not store values

D Cache contains both Alice and Bob objects under key 1

💡 Hint

Consider what happens when the same key is updated twice.

@CachePut updates the cache with the returned value each time. The second call overwrites the first cached value for key 1.

🧠 Conceptual

expert

Why use @CachePut instead of @Cacheable when updating data?

Which reason best explains why @CachePut is preferred over @Cacheable for methods that update data?

A @CachePut skips method execution if cache has the key, improving performance.

B @CachePut only caches null results to reduce cache size.

C @CachePut always executes the method and updates the cache, ensuring cache consistency after data changes.

D @CachePut clears the entire cache before method execution to avoid stale data.

💡 Hint

Think about cache consistency when data changes.

@CachePut ensures the method runs and the cache is updated with fresh data. @Cacheable may skip method execution and return stale cache data, which is not suitable for updates.

Practice

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

easy

A. To update the cache with the method's return value after execution

B. To clear all entries in the cache before method execution

C. To cache the method result only if it is not already cached

D. To disable caching for the annotated method

Solution

1. Step 1: Understand the role of @CachePut

   @CachePut is used to update the cache with fresh data after the method runs, unlike @Cacheable which caches only if data is absent.

2. Step 2: Compare options with @CachePut behavior

   Only To update the cache with the method's return value after execution correctly describes updating the cache after method execution. Others describe different caching behaviors.

3. Final Answer:

   To update the cache with the method's return value after execution -> Option A

4. Quick Check:

   @CachePut updates cache after method runs [OK]

Hint: Remember: @CachePut always updates cache after method runs [OK]

Common Mistakes:

• Confusing @CachePut with @Cacheable
• Thinking @CachePut clears cache
• Assuming it caches only if absent

2. Which of the following is the correct syntax to use @CachePut to update a cache named "users" with a key based on the method parameter id?

easy

A. @CachePut(cacheName = "users", key = "id")

B. @CachePut(value = "users", key = "#id")

C. @CachePut(name = "users", key = "id")

D. @CachePut(cache = "users", key = "#id")

Solution

1. Step 1: Recall correct attribute names for @CachePut

   The correct attribute for cache name is 'value' or 'cacheNames', and SpEL expressions for keys use '#'.

2. Step 2: Analyze each option's syntax

   @CachePut(value = "users", key = "#id") uses 'value' and '#id' correctly. Others use incorrect attribute names or miss the '#' for SpEL.

3. Final Answer:

   @CachePut(value = "users", key = "#id") -> Option B

4. Quick Check:

   Use 'value' and '#param' for key in @CachePut [OK]

Hint: Use 'value' for cache name and '#' before param in key [OK]

Common Mistakes:

• Using wrong attribute names like cacheName or cache
• Missing '#' in key expression
• Using plain string instead of SpEL for key

3. Given the following method in a Spring Boot service:

@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
    product.setPrice(product.getPrice() + 10);
    return product;
}

What will be the effect on the cache when this method is called with a product having id=5 and price=100?

medium

A. The cache is not affected because @CachePut only caches if absent

B. The cache entry with key 5 is removed from the cache

C. The cache entry with key 5 is updated with the product having price 110

D. A new cache entry with key 110 is added

Solution

1. Step 1: Understand @CachePut behavior on method call

   @CachePut updates the cache entry with the key specified after the method returns the updated object.

2. Step 2: Analyze the method logic and cache key

   The method increases price by 10 and returns the product. The key is product.id which is 5, so cache key 5 is updated with product price 110.

3. Final Answer:

   The cache entry with key 5 is updated with the product having price 110 -> Option C

4. Quick Check:

   @CachePut updates cache key with returned value [OK]

Hint: Returned value updates cache at key specified [OK]

Common Mistakes:

• Thinking cache key changes to price
• Assuming cache entry is removed
• Confusing @CachePut with @Cacheable

4. Consider this method annotated with @CachePut:

@CachePut(value = "orders", key = "#order.id")
public Order updateOrder(Order order) {
    // missing return statement
}

What is the problem with this code?

medium

A. The method should be annotated with @Cacheable instead

B. The key expression is invalid and causes a syntax error

C. The cache name 'orders' is not allowed in @CachePut

D. The method does not return a value, so cache cannot be updated

Solution

1. Step 1: Check method return requirement for @CachePut

   @CachePut requires the method to return a value to update the cache with that value.

2. Step 2: Identify missing return statement issue

   The method lacks a return statement, so no value is returned to update the cache, causing runtime issues.

3. Final Answer:

   The method does not return a value, so cache cannot be updated -> Option D

4. Quick Check:

   @CachePut needs method return to update cache [OK]

Hint: Always return updated value when using @CachePut [OK]

Common Mistakes:

• Forgetting to return the updated object
• Confusing cache name attribute
• Using @Cacheable instead of @CachePut incorrectly

5. You have a method that updates a user's email and you want to ensure the cache entry for that user is updated immediately after the change. Which approach correctly uses @CachePut to achieve this, assuming the method signature is public User updateEmail(Long userId, String newEmail)?

hard

A. @CachePut(value = "users", key = "#userId")
public User updateEmail(Long userId, String newEmail) {
User user = userRepository.findById(userId);
user.setEmail(newEmail);
userRepository.save(user);
return user;
}

B. @CachePut(value = "users", key = "#newEmail")
public User updateEmail(Long userId, String newEmail) {
User user = userRepository.findById(userId);
user.setEmail(newEmail);
userRepository.save(user);
return user;
}

C. @CachePut(value = "users")
public void updateEmail(Long userId, String newEmail) {
User user = userRepository.findById(userId);
user.setEmail(newEmail);
userRepository.save(user);
}

D. @CachePut(key = "#userId")
public User updateEmail(Long userId, String newEmail) {
User user = userRepository.findById(userId);
user.setEmail(newEmail);
userRepository.save(user);
return user;
}

Solution

1. Step 1: Verify correct cache name and key usage

   @CachePut(value = "users", key = "#userId") public User updateEmail(Long userId, String newEmail) { User user = userRepository.findById(userId); user.setEmail(newEmail); userRepository.save(user); return user; } uses 'value = "users"' and key '#userId', correctly identifying the cache and key.

2. Step 2: Check method return and update logic

   @CachePut(value = "users", key = "#userId") public User updateEmail(Long userId, String newEmail) { User user = userRepository.findById(userId); user.setEmail(newEmail); userRepository.save(user); return user; } returns the updated User object, which is necessary for @CachePut to update the cache. Other options either use wrong key, no return, or missing cache name.

3. Final Answer:

   @CachePut(value = "users", key = "#userId") public User updateEmail(Long userId, String newEmail) { User user = userRepository.findById(userId); user.setEmail(newEmail); userRepository.save(user); return user; } -> Option A

4. Quick Check:

   Return updated object and use correct cache name and key [OK]

Hint: Return updated object and use correct cache name and key [OK]

Common Mistakes:

• Using wrong key expression
• Not returning updated object
• Omitting cache name in annotation