Cache key strategies in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a cache key in Spring Boot caching?

A cache key is a unique identifier used to store and retrieve cached data. It helps the cache know which data to return for a given request.

beginner

Why should cache keys be unique and consistent?

Unique and consistent keys ensure the cache returns the correct data every time. If keys are not unique, cached data can be overwritten or mixed up, causing errors.

intermediate

Name two common strategies to create cache keys in Spring Boot.

1. Using method parameters directly as keys.
2. Using a custom key generator to build keys from multiple parameters or objects.

intermediate

What is the role of a custom key generator in Spring Boot caching?

A custom key generator creates cache keys based on complex logic, like combining multiple method parameters or formatting keys for better uniqueness and readability.

advanced

How can improper cache key design affect application performance?

If cache keys are not well designed, cache hits decrease, causing more database calls and slower responses. It can also lead to stale or incorrect data being served.

What does a cache key uniquely identify in Spring Boot caching?

A The application server

B The database connection

C Cached data for a specific method call

D The user interface layout

Cache keys identify cached data related to specific method calls and their parameters.

Which of these is a good practice for cache keys?

A Use method parameters consistently

B Use random strings every time

C Use the current timestamp

D Use the user's IP address only

Using method parameters consistently ensures cache keys are unique and repeatable.

What happens if two different method calls produce the same cache key?

A Cache overwrites previous data causing errors

B Cache stores both separately

C Cache ignores the second call

D Cache creates a new cache region

Same keys cause overwriting, leading to wrong data being returned.

What is a benefit of using a custom key generator?

A It slows down caching

B It allows complex keys from multiple parameters

C It disables caching

D It encrypts cache data

Custom key generators help create meaningful keys from complex inputs.

Which is NOT a good cache key strategy?

A Combining method name and parameters

B Using a hash of parameters

C Using a custom key generator

D Using a fixed constant key for all calls

Using a fixed key causes all cached data to collide, breaking caching.

Explain why cache keys must be unique and consistent in Spring Boot caching.

Think about what happens if keys repeat or change unexpectedly.

Describe two ways to create cache keys in Spring Boot and when you might use each.

Consider simple methods versus methods with multiple or complex inputs.

Practice

1. What is the main purpose of a cache key in Spring Boot caching?

easy

A. To define the cache size limit

B. To store the actual data in the cache

C. To uniquely identify cached data for quick retrieval

D. To clear the cache automatically

Solution

1. Step 1: Understand cache key role

   A cache key uniquely identifies the cached data so the system can find it quickly without confusion.

2. Step 2: Differentiate from other cache functions

   Cache keys do not store data or control cache size; they only act as unique identifiers.

3. Final Answer:

   To uniquely identify cached data for quick retrieval -> Option C

4. Quick Check:

   Cache key = unique identifier [OK]

Hint: Cache keys uniquely identify data to find it fast [OK]

Common Mistakes:

• Thinking cache keys store data
• Confusing keys with cache size settings
• Assuming keys clear cache automatically

2. Which of the following is the correct way to specify a cache key using Spring Expression Language (SpEL) in the @Cacheable annotation?

easy

A. @Cacheable(key = "#user.id")

B. @Cacheable(key = user.id)

C. @Cacheable(key = "user.id")

D. @Cacheable(key = #user.id)

Solution

1. Step 1: Recognize SpEL syntax in @Cacheable

   SpEL expressions must be inside double quotes and start with # to reference method parameters.

2. Step 2: Check each option

   @Cacheable(key = "#user.id") correctly uses "#user.id" as a string with # for SpEL. @Cacheable(key = user.id) misses quotes, the option with "user.id" misses #, @Cacheable(key = #user.id) misses quotes.

3. Final Answer:

   @Cacheable(key = "#user.id") -> Option A

4. Quick Check:

   SpEL key syntax = quoted string with # [OK]

Hint: SpEL keys need quotes and # before variable [OK]

Common Mistakes:

• Omitting quotes around SpEL expression
• Forgetting # before parameter name
• Using plain variable without SpEL syntax

3. Given the method annotated as @Cacheable(value = "users", key = "#id"), what will be the cache key when calling getUser(42)?

medium

A. "id"

B. 42

C. "#id"

D. null

Solution

1. Step 1: Understand key expression #id

   The key uses SpEL #id which means the method parameter named id's value is used as the key.

2. Step 2: Substitute method call parameter

   Calling getUser(42) means id = 42, so the cache key is 42 (an integer).

3. Final Answer:

   42 -> Option B

4. Quick Check:

   Key = parameter value 42 [OK]

Hint: Cache key #param uses actual parameter value [OK]

Common Mistakes:

• Using the string '#id' instead of parameter value
• Confusing key with parameter name only
• Assuming null key if not specified

4. Identify the error in this cache key definition: @Cacheable(value = "items", key = "#item.id + #item.name")

medium

A. SpEL expressions cannot concatenate strings with + operator

B. Missing parentheses around the expression

C. The key must be a constant string, not an expression

D. Using + operator without converting to string may cause wrong key

Solution

1. Step 1: Analyze SpEL expression with + operator

   In SpEL, + can add numbers or concatenate strings. If item.id is numeric, adding to item.name (string) may cause type issues.

2. Step 2: Understand type conversion in keys

   Without explicit string conversion, adding number + string may produce unexpected keys or errors.

3. Final Answer:

   Using + operator without converting to string may cause wrong key -> Option D

4. Quick Check:

   Type mismatch in key expression = error [OK]

Hint: Convert all parts to string before concatenation in keys [OK]

Common Mistakes:

• Assuming + always concatenates strings
• Not converting numeric parts to string explicitly
• Thinking key must be constant string only

5. You want to cache results of a method that takes two parameters: userId (Long) and filter (String). Which cache key strategy ensures unique keys for each combination?

hard

A. Use key = "T(java.util.Objects).hash(#userId, #filter)"

B. Use key = "#userId + #filter" without conversion

C. Use key = "#userId" only

D. Use key = "#filter" only

Solution

1. Step 1: Understand need for unique keys per parameter combo

   Using only one parameter as key risks collisions when other parameter changes.

2. Step 2: Evaluate options for combining parameters

   Use key = "#userId + #filter" without explicit conversion risks type issues. Use key = "T(java.util.Objects).hash(#userId, #filter)" uses Java's Objects.hash to combine both safely. Using only one parameter causes collisions.

3. Final Answer:

   Use key = "T(java.util.Objects).hash(#userId, #filter)" -> Option A

4. Quick Check:

   Combine keys safely with Objects.hash [OK]

Hint: Use Objects.hash to combine multiple parameters safely [OK]

Common Mistakes:

• Concatenating keys without type safety
• Using only one parameter as key causing collisions
• Ignoring proper SpEL syntax for static method calls