Can you explain the caching mechanisms available in Spring Boot?

Question

Accepted Answer

Caching in Spring Boot is a performance optimization technique that stores the results of expensive operations such as database queries, API calls, or complex calculations in memory. When the same request arrives again, the application retrieves the data from the cache instead of executing the operation repeatedly, significantly improving response time and reducing system load.

Key Points:
• Spring Boot provides a Cache Abstraction that works with multiple cache providers.
• Caching reduces database calls and improves application throughput.
• Cache behavior is controlled using annotations such as @Cacheable, @CachePut, and @CacheEvict.

Example:
Consider an e-commerce application where product details are requested thousands of times every hour.

Without Cache:
Client Request
      ↓
Database Query
      ↓
Return Response

With Cache:
First Request
      ↓
Database Query
      ↓
Store Result in Cache
      ↓
Return Response

Subsequent Requests
      ↓
Fetch Data from Cache
      ↓
Return Response

This eliminates unnecessary database access and improves performance.

Code Example:

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

@Service
public class ProductService {

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

System.out.println(
                "Fetching from database");
```
        return repository.findById(id)
```
                .orElseThrow();
    }
}
```
Cache Management Annotations:

1. @Cacheable
• Stores method results in cache.
• If data exists in cache, method execution is skipped.

2. @CachePut
• Updates the cache with the latest value.
• Method executes every time.

3. @CacheEvict
• Removes entries from cache.
• Useful after update or delete operations.

Example:

@CacheEvict(
        value = "products",
        key = "#id")
```
public void deleteProduct(
        Long id) {
}
```
Available Cache Providers:

• ConcurrentMapCache
• Caffeine
• EhCache
• Redis
• Hazelcast
• Infinispan

Common Usage Scenarios:

• Product Catalog
• User Profiles
• Country and Currency Data
• Configuration Data
• Frequently Accessed Reports

Local Cache vs Distributed Cache:

Local Cache:
• Stored inside application memory.
• Faster access.
• Example: Caffeine, EhCache.

Distributed Cache:
• Shared across multiple application instances.
• Suitable for microservices and clustered environments.
• Example: Redis, Hazelcast.

Real-World Example:

An online shopping application caches:

• Product Details
• Category Information
• Pricing Data

Before Caching:
• Database Calls: 10,000 per minute
• Average Response Time: 800 ms

After Caching:
• Database Calls: 1,000 per minute
• Average Response Time: 120 ms

Benefits:

• Faster response times.
• Reduced database load.
• Improved scalability.
• Better user experience.
• Lower infrastructure costs.

Best Practices:

• Cache only frequently accessed data.
• Define cache expiration policies.
• Avoid caching highly volatile data.
• Use distributed caching in microservices environments.

Interview Tip:
A concise interview answer is: Spring Boot provides a cache abstraction that supports multiple cache providers such as Caffeine, EhCache, and Redis. Using annotations like @Cacheable, @CachePut, and @CacheEvict, we can store frequently accessed data in memory, reduce database calls, and significantly improve application performance and scalability.