Why caching matters for performance in Spring Boot - See It in Action

Why caching matters for performance

📖 Scenario: You are building a simple Spring Boot application that fetches user data from a slow database. To improve performance, you want to add caching so repeated requests for the same user do not hit the database every time.

🎯 Goal: Build a Spring Boot service that caches user data after the first fetch to speed up subsequent requests.

📋 What You'll Learn

Create a Map<Integer, String> to simulate a slow database with user IDs and names

Add a boolean variable cacheEnabled to control caching

Implement a method getUserName(int userId) that uses caching when cacheEnabled is true

Add a cache Map<Integer, String> to store fetched user names

💡 Why This Matters

🌍 Real World

Caching is used in real applications to speed up data access and reduce load on databases or external services.

💼 Career

Understanding caching is important for backend developers to build efficient, scalable applications.

1

DATA SETUP: Create a simulated database

Create a Map<Integer, String> called userDatabase with these exact entries: 1: "Alice", 2: "Bob", 3: "Charlie".

Spring Boot

// Your code here

Hint

Use Map.of() to create the userDatabase with the exact user IDs and names.

2

CONFIGURATION: Add a cache control variable

Add a boolean variable called cacheEnabled and set it to true inside the UserService class.

Spring Boot

import java.util.Map;
import java.util.HashMap;

public class UserService {
    private Map userDatabase = Map.of(
        1, "Alice",
        2, "Bob",
        3, "Charlie"
    );
    // Your code here
}

Hint

Declare cacheEnabled as a private boolean and set it to true.

3

CORE LOGIC: Implement caching in the user fetch method

Add a private Map<Integer, String> called userCache initialized as an empty HashMap. Then create a public method getUserName(int userId) that returns the user name. If cacheEnabled is true, first check userCache for the user name. If not found, get it from userDatabase, store it in userCache, and return it. If cacheEnabled is false, return directly from userDatabase.

Spring Boot

import java.util.Map;
import java.util.HashMap;

public class UserService {
    private Map userDatabase = Map.of(
        1, "Alice",
        2, "Bob",
        3, "Charlie"
    );
    private boolean cacheEnabled = true;

    // Your code here
}

Hint

Use userCache.containsKey(userId) to check cache, and userCache.put(userId, userName) to store new entries.

4

COMPLETION: Add a method to clear the cache

Add a public method called clearCache() that clears all entries from userCache.

Spring Boot

import java.util.Map;
import java.util.HashMap;

public class UserService {
    private Map userDatabase = Map.of(
        1, "Alice",
        2, "Bob",
        3, "Charlie"
    );
    private boolean cacheEnabled = true;
    private Map userCache = new HashMap();

    public String getUserName(int userId) {
        if (cacheEnabled) {
            if (userCache.containsKey(userId)) {
                return userCache.get(userId);
            } else {
                String userName = userDatabase.get(userId);
                userCache.put(userId, userName);
                return userName;
            }
        } else {
            return userDatabase.get(userId);
        }
    }

    // Your code here
}

Hint

Use userCache.clear() inside the clearCache() method to empty the cache.

Practice

1. Why is caching important in a Spring Boot application?

easy

A. It disables database connections

B. It increases the size of the application

C. It makes the code harder to read

D. It stores results to avoid repeating slow operations

Solution

1. Step 1: Understand caching purpose

   Caching stores the results of expensive or slow operations so they can be reused later without repeating the work.

2. Step 2: Identify the benefit in Spring Boot

   By caching method results, Spring Boot avoids repeated slow calls, improving performance.

3. Final Answer:

   It stores results to avoid repeating slow operations -> Option D

4. Quick Check:

   Caching improves speed by reusing results [OK]

Hint: Caching saves time by reusing previous results [OK]

Common Mistakes:

• Thinking caching increases app size negatively
• Believing caching disables database connections
• Confusing caching with code complexity

2. Which annotation enables caching on a method in Spring Boot?

easy

A. @Cacheable

B. @CacheEvict

C. @CachePut

D. @EnableCaching

Solution

1. Step 1: Identify method-level caching annotation

   @Cacheable is used on methods to indicate their results should be cached.

2. Step 2: Differentiate from other caching annotations

   @EnableCaching enables caching globally, but @Cacheable marks specific methods for caching.

3. Final Answer:

   @Cacheable -> Option A

4. Quick Check:

   Method caching uses @Cacheable [OK]

Hint: Use @Cacheable on slow methods to cache results [OK]

Common Mistakes:

• Confusing @EnableCaching with method-level caching
• Using @CachePut or @CacheEvict incorrectly for caching results
• Forgetting to annotate methods with @Cacheable

3. Given this method with caching enabled:

@Cacheable("books")
public Book findBook(String id) {
  simulateSlowService();
  return new Book(id, "Title");
}

What happens when findBook("123") is called twice?

medium

A. The method runs slowly both times

B. The method runs slowly the first time, fast the second time

C. The method runs fast both times

D. The method throws an error on second call

Solution

1. Step 1: Understand @Cacheable behavior

   The first call runs the method and caches the result. The second call returns the cached result without running the method again.

2. Step 2: Analyze the call times

   First call is slow due to simulateSlowService(), second call is fast because it uses cache.

3. Final Answer:

   The method runs slowly the first time, fast the second time -> Option B

4. Quick Check:

   Cache speeds up repeated calls [OK]

Hint: First call caches result; second call returns cached data [OK]

Common Mistakes:

• Assuming method runs slowly every time
• Thinking cache causes errors on repeated calls
• Believing cache makes all calls fast immediately

4. What is wrong with this Spring Boot caching code?

@Cacheable("users")
public User getUser(int id) {
  return userRepository.findById(id).get();
}

// Missing @EnableCaching annotation in main class

medium

A. The method signature is incorrect

B. The cache name "users" is invalid

C. Caching won't work without @EnableCaching annotation

D. The repository call is wrong

Solution

1. Step 1: Check caching setup requirements

   Spring Boot requires @EnableCaching on a configuration or main class to activate caching support.

2. Step 2: Identify missing annotation impact

   Without @EnableCaching, @Cacheable annotations are ignored and caching does not work.

3. Final Answer:

   Caching won't work without @EnableCaching annotation -> Option C

4. Quick Check:

   @EnableCaching is required to activate caching [OK]

Hint: Always add @EnableCaching to activate caching [OK]

Common Mistakes:

• Assuming @Cacheable works without enabling caching
• Thinking cache name must be special format
• Believing method signature causes caching failure

5. You have a method that fetches user data from a slow API. You want to cache results but refresh cache every 10 minutes. Which approach best achieves this in Spring Boot?

hard

A. Use @Cacheable and configure cache manager with 10-minute TTL

B. Use @CachePut to update cache on every call

C. Use @CacheEvict to clear cache only on application restart

D. Do not use caching to avoid stale data

Solution

1. Step 1: Understand caching with expiration

   To refresh cached data periodically, configure the cache manager with a time-to-live (TTL) setting.

2. Step 2: Match annotation with cache manager config

   @Cacheable caches method results; TTL in cache manager ensures cache expires after 10 minutes automatically.

3. Final Answer:

   Use @Cacheable and configure cache manager with 10-minute TTL -> Option A

4. Quick Check:

   TTL + @Cacheable refreshes cache periodically [OK]

Hint: Set TTL in cache manager with @Cacheable for timed refresh [OK]

Common Mistakes:

• Using @CachePut causes cache update every call, no TTL
• Relying on @CacheEvict only on restart misses timed refresh
• Avoiding caching loses performance benefits