Cache key strategies in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding default cache key generation in Spring Boot

In Spring Boot's caching abstraction, what does the default cache key consist of when no custom key is specified?

A Only the first method parameter value

B The method parameters

C A random UUID generated for each cache entry

D The method name as a string

💡 Hint

Think about what uniquely identifies a method call with parameters in caching.

By default, Spring Boot uses the method parameters to generate a unique cache key using SimpleKeyGenerator. This ensures that different calls with different parameters are cached separately.

❓ component_behavior

intermediate

Effect of @Cacheable key attribute with SpEL expression

Given the following method in a Spring Boot service:

@Cacheable(value = "users", key = "#user.id")
public User getUser(User user) { ... }

What will be used as the cache key when this method is called?

Spring Boot

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

A The id property of the user object passed as parameter

B The default key generated from all method parameters

C The entire user object serialized

D The string "#user.id" literally

💡 Hint

Look at the SpEL expression inside the key attribute.

The key attribute uses Spring Expression Language (SpEL). Here, #user.id extracts the id property from the user parameter to use as the cache key.

📝 Syntax

advanced

Correct SpEL syntax for composite cache key

Which of the following @Cacheable key expressions correctly creates a composite key from two method parameters named 'id' and 'type'?

A #id & #type

B #id, #type

C {#id, #type}

D #id + '-' + #type

💡 Hint

Think about how to concatenate strings in SpEL.

In SpEL, the plus sign (+) concatenates strings. So #id + '-' + #type creates a string key combining both parameters separated by a dash.

🔧 Debug

advanced

Identifying cache key error causing cache misses

A developer uses @Cacheable with key = "#user" on a method with a User parameter. The cache never hits even when called with the same User object. What is the most likely cause?

Spring Boot

@Cacheable(value = "users", key = "#user")
public User getUser(User user) { ... }

A User class does not override equals() and hashCode(), so keys differ despite same data

B The key expression "#user" is invalid SpEL syntax causing runtime error

C The cache value name "users" is reserved and causes conflicts

D The method parameter must be primitive types only for caching

💡 Hint

Think about how objects are compared as keys in caches.

When using an object as a cache key, it must properly implement equals() and hashCode(). Otherwise, different instances with same data are treated as different keys, causing cache misses.

❓ state_output

expert

Cache key behavior with complex nested parameters

Consider a method annotated with @Cacheable(value = "orders") that takes an Order object with nested Customer object. The key is set as "#order.customer.id". If two different Order objects have the same Customer id, what will happen when caching?

Spring Boot

@Cacheable(value = "orders", key = "#order.customer.id")
public Order getOrder(Order order) { ... }

A Each call creates a separate cache entry because the Order objects differ

B Cache will throw an error due to nested property access in key

C Both calls will share the same cache entry because the key is the same customer id

D Cache will ignore the key and use default key generation

💡 Hint

Focus on what the key expression evaluates to.

The key expression uses only the customer id, so different Order objects with the same customer id will map to the same cache key, sharing the cached result.