Cache configuration in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Spring Boot cache example?

Consider a Spring Boot service method annotated with @Cacheable("books"). If the method is called twice with the same argument, what happens on the second call?

Spring Boot

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    @Cacheable("books")
    public String findBook(String isbn) {
        System.out.println("Fetching book for " + isbn);
        return "Book-" + isbn;
    }
}

// In main application or test:
// bookService.findBook("123");
// bookService.findBook("123");

A The method prints "Fetching book for 123" twice and returns the same result both times.

B The method throws a runtime exception because caching is not enabled by default.

C The method prints "Fetching book for 123" once and returns cached result on the second call without printing.

D The method returns null on the second call because cache is cleared automatically.

💡 Hint

Think about what @Cacheable does when the same argument is used multiple times.

The @Cacheable annotation caches the result of the method for the given argument. On the first call, the method runs and prints the message. On the second call with the same argument, the cached result is returned without executing the method body, so no print occurs.

📝 Syntax

intermediate

Which cache configuration snippet correctly enables caching in Spring Boot?

Select the correct way to enable caching in a Spring Boot application.

A

@EnableCaching
@SpringBootApplication
public class App {}

B

@EnableCache
@SpringBootApplication
public class App {}

C

@EnableCaching
@Component
public class App {}

D

@Cacheable
@SpringBootApplication
public class App {}

💡 Hint

Look for the correct annotation to enable caching support.

The correct annotation to enable caching in Spring Boot is @EnableCaching. It should be placed on a configuration or main application class, often alongside @SpringBootApplication.

🔧 Debug

advanced

Why does the cache not store values in this Spring Boot example?

Given this code, why is the cache never hit and the method always executes?

Spring Boot

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Cacheable("users")
    public String getUser(int id) {
        System.out.println("Loading user " + id);
        return "User-" + id;
    }
}

// Called from the same class method:
// public void process() {
//     getUser(1);
//     getUser(1);
// }

A Because the method parameter is a primitive type, caching does not work with primitives.

B Because the cache name "users" is invalid and caching silently fails.

C Because @Cacheable requires @CachePut to work properly in the same class.

D Because the method is called from within the same class, Spring's proxy does not intercept the call, so caching is bypassed.

💡 Hint

Think about how Spring AOP proxies work and method calls inside the same class.

Spring caching uses proxies to intercept method calls. When a method annotated with @Cacheable is called from within the same class, the proxy is bypassed, so caching does not happen.

❓ state_output

advanced

What is the size of the cache after these calls?

Given a cache named "products" and this sequence of calls, how many entries are stored in the cache?

Spring Boot

productService.getProduct(1);
productService.getProduct(2);
productService.getProduct(1);
productService.getProduct(3);
productService.getProduct(2);

A 5 entries

B 3 entries

C 2 entries

D 4 entries

💡 Hint

Remember that cache stores unique keys and repeated calls with same key do not add new entries.

The cache stores one entry per unique key. The calls with keys 1, 2, and 3 add three entries. Repeated calls with keys 1 and 2 do not add new entries.

🧠 Conceptual

expert

Which statement about Spring Boot cache eviction is correct?

Consider a method annotated with @CacheEvict(value = "sessions", allEntries = true). What does this annotation do when the method is called?

A It removes all entries from the "sessions" cache immediately after the method executes.

B It removes only the cache entry matching the method's argument from "sessions" before the method executes.

C It disables caching for the "sessions" cache permanently.

D It clears the cache only if the method throws an exception.

💡 Hint

Focus on the meaning of allEntries=true in @CacheEvict.

@CacheEvict with allEntries=true clears all entries in the specified cache after the annotated method finishes successfully.