How would you implement caching in a Spring Boot application?

Question

Accepted Answer

Caching in Spring Boot is a performance optimization technique that stores the results of expensive operations in memory so that repeated requests can be served quickly without executing the same logic or database queries again.

Key Points:
• Caching reduces database load and improves application response time.
• Spring Boot provides annotation-based caching support with minimal configuration.
• Cache providers such as Redis, EhCache, Caffeine, and Hazelcast can be integrated easily.

Example:
Consider an e-commerce application where thousands of users request product information.

Without Caching:

Client Request
      ↓
Application
      ↓
Database Query
      ↓
Response

Every request hits the database.

With Caching:

First Request:
Client
   ↓
Application
   ↓
Database
   ↓
Cache Store
   ↓
Response

Subsequent Requests:
Client
   ↓
Application
   ↓
Cache
   ↓
Response

This significantly improves performance and reduces database traffic.

Code Example:

```
@SpringBootApplication
@EnableCaching
public class Application {
}

@Service
public class ProductService {

@Cacheable("products")
    public Product getProduct(Long id) {

System.out.println(
            "Fetching from database...");
```
        return productRepository.findById(id)
```
                .orElseThrow();
    }
}
```
When the method is called for the first time:

• Data is fetched from the database.
• Result is stored in cache.

For subsequent requests with the same id:

• Data is returned directly from cache.
• Database access is skipped.

Important Caching Annotations:

1. @Cacheable

Purpose:
• Stores method results in cache.

2. @CacheEvict

Purpose:
• Removes data from cache.

Example:

@CacheEvict(value = "products",
            key = "#id")
```
public void deleteProduct(Long id) {
}
```
3. @CachePut

Purpose:
• Updates cache with the latest value.

Example:

@CachePut(value = "products",
          key = "#product.id")
```
public Product updateProduct(
        Product product) {
}
```
Supported Cache Providers:

• ConcurrentHashMap (Default)
• Redis
• Caffeine
• EhCache
• Hazelcast
• Infinispan

Provider Selection:

Small Applications:
• Caffeine
• ConcurrentMapCache

Distributed Systems:
• Redis
• Hazelcast

Real-World Example:

E-Commerce Platform:

Cached Data:
• Product Details
• Categories
• Pricing Information
• Configuration Data

This reduces database queries during high traffic events such as flash sales.

Best Practices:

• Cache frequently accessed and rarely changing data.
• Avoid caching highly dynamic data.
• Configure proper cache expiration policies.
• Use distributed caches for microservices environments.
• Monitor cache hit and miss ratios.

Interview Tip:
A concise interview answer is: To implement caching in Spring Boot, I would add a cache provider dependency, enable caching using @EnableCaching, and use annotations such as @Cacheable, @CacheEvict, and @CachePut to manage cached data. For production systems, Redis or Caffeine are commonly used cache providers to improve performance and reduce database load.