@Cacheable for read caching in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a method annotated with @Cacheable is called multiple times with the same argument?

Consider a Spring Boot service method annotated with @Cacheable. What is the behavior when this method is called multiple times with the same input?

Spring Boot

public class ProductService {

  @Cacheable("products")
  public Product getProductById(Long id) {
    simulateSlowService();
    return new Product(id, "Product " + id);
  }

  private void simulateSlowService() {
    try {
      Thread.sleep(3000L);
    } catch (InterruptedException e) {
      throw new IllegalStateException(e);
    }
  }
}

A The method executes only once per unique argument; subsequent calls return cached result instantly.

B The method executes fully every time, ignoring the cache.

C The method caches the result but still executes every time.

D The method throws an exception if called more than once with the same argument.

💡 Hint

Think about how caching avoids repeated work for the same input.

The @Cacheable annotation tells Spring to cache the method's result for each unique argument. On subsequent calls with the same argument, the cached value is returned immediately without executing the method body again.

📝 Syntax

intermediate

Which @Cacheable annotation syntax correctly caches a method result with a custom cache name and key?

Choose the correct @Cacheable annotation usage to cache a method result in cache named "users" using the method's first argument as the key.

Spring Boot

public User getUserById(Long id) { ... }

A @Cacheable(value = "users", key = "id")

B @Cacheable(cache = "users", key = "#id")

C @Cacheable(cacheNames = "users", key = "#id")

D @Cacheable(cacheNames = "users", key = "id")

💡 Hint

Remember the SpEL syntax for keys uses # before parameter names.

The correct syntax uses cacheNames or value for cache name and SpEL expression #id to refer to the method parameter named id.

🔧 Debug

advanced

Why does the @Cacheable annotation not cache the method result in this Spring service?

Given the following Spring service, why is the caching not working as expected?

Spring Boot

public class OrderService {

  @Cacheable("orders")
  public Order getOrder(Long id) {
    return fetchOrderFromDb(id);
  }

  public Order fetchOrderFromDb(Long id) {
    // Simulate DB call
    return new Order(id, "Order " + id);
  }

  public Order getCachedOrder(Long id) {
    return getOrder(id);
  }
}

A The fetchOrderFromDb method should be annotated with @Cacheable instead.

B The method getOrder is called internally by getCachedOrder, so Spring proxy does not intercept the call to apply caching.

C The cache name "orders" is invalid and causes caching to fail silently.

D The Order class must implement Serializable for caching to work.

💡 Hint

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

Spring uses proxies to apply caching. Internal method calls within the same class bypass the proxy, so @Cacheable is not triggered when getOrder is called from getCachedOrder.

❓ state_output

advanced

What is the output when calling a @Cacheable method twice with different arguments?

Consider this Spring Boot service method:

  @Cacheable("items")
  public String getItemName(int id) {
    System.out.println("Fetching item " + id);
    return "Item" + id;
  }

What will be printed to the console when calling getItemName(1) and then getItemName(2)?

A

Fetching item 2
Fetching item 1

B

Fetching item 1
(no output for second call)

C (no output for both calls)

D

Fetching item 1
Fetching item 2

💡 Hint

Remember caching stores results per unique argument.

Each unique argument causes the method to execute once. So calling with 1 prints once, then calling with 2 prints once. Both calls print because arguments differ.

🧠 Conceptual

expert

Which statement about @Cacheable behavior is TRUE regarding null return values?

In Spring Boot, when a method annotated with @Cacheable returns null, what happens by default?

A Null values are never cached by default; the method executes every time for null results.

B Null values are cached by default, so subsequent calls return null from cache.

C Caching null values causes a runtime exception unless configured otherwise.

D Null values are cached only if the cache manager supports it explicitly.

💡 Hint

Think about why caching nulls might be problematic.

By default, Spring does not cache null return values to avoid caching absence of data. The method runs every time if it returns null.