Caching REST API Responses

Caching is a key optimization technique that improves the performance and scalability of REST APIs. By storing frequently accessed data, caching reduces the response time and server load, making applications faster and more efficient.

In this article, we will cover:

✔ What is Caching?
 ✔ Why Caching is Important for REST APIs?
 ✔ Types of Caching
 ✔ How to Implement Caching in Spring Boot REST API?
 ✔ Best Practices for Caching

Let’s get started! 🚀

🔹 What is Caching?

Caching is the process of storing frequently requested data in memory or disk to reduce repeated database or API calls. Instead of fetching the same data again and again, caching returns stored data, making APIs much faster.

🔹 Why is Caching Important for REST APIs?

✅ Reduces server load — Fewer database and API calls.
 ✅ Improves response time — Returns data quickly from cache.
 ✅ Enhances scalability — Handles more users with less resource usage.
 ✅ Reduces bandwidth usage — Cached responses prevent unnecessary data transfers.

🔹 Types of Caching in REST APIs

REST APIs support two main types of caching:

1️⃣ Client-Side Caching

• The client (browser, mobile app) caches responses.
• Uses HTTP caching headers (Cache-Control, ETag, etc.).

📌 Example: Setting Cache Headers in API Response

Cache-Control: max-age=3600  # Cache response for 1 hour
ETag: "12345"  # Unique identifier for response version

💡 Used When: The same client requests repeated data (e.g., a user’s dashboard).

2️⃣ Server-Side Caching

• The server caches responses to reduce repeated processing.
• Uses in-memory stores like Redis, Ehcache, or Hazelcast.

📌 Example: Caching API Responses in Redis

import redis

cache = redis.Redis(host='localhost', port=6379, db=0)

# Check cache before hitting database
data = cache.get("products")
if data is None:
    data = get_products_from_database()
    cache.set("products", data, ex=3600)  # Cache for 1 hour

💡 Used When: Multiple users request the same data (e.g., product listings).

🔹 How to Implement Caching in Spring Boot REST API?

Spring Boot provides easy caching support using Spring Cache Abstraction with Redis, Ehcache, or Caffeine.

1️⃣ Enable Caching in Spring Boot

Add the @EnableCaching annotation in your main class.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableCaching  // Enables caching
public class ProductServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }
}

2️⃣ Use @Cacheable for Caching API Responses

The @Cacheable annotation stores the API response in cache and returns cached data for future requests.

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

@Service
public class ProductService {
    
    @Cacheable(value = "products") // Caches response under "products" key
    public List<Product> getAllProducts() {
        simulateSlowService(); // Simulate slow DB call
        return List.of(new Product(1, "Laptop"), new Product(2, "Phone"));
    }

    private void simulateSlowService() {
        try {
            Thread.sleep(3000); // Simulate delay (3 seconds)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

📌 Without caching: Every request takes 3 seconds.
 📌 With caching: Subsequent requests return instantly from cache.

3️⃣ Configure Caching with Redis (High Performance)

Add Redis dependencies in pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

📌 Configure Redis in application.properties

spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379

📌 Use Redis to Cache API Responses

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

@Service
public class ProductService {

    @Cacheable(value = "productsCache")
    public List<Product> getAllProducts() {
        return List.of(new Product(1, "Laptop"), new Product(2, "Phone"));
    }
}

🚀 Now, responses are cached in Redis, improving performance!

🔹 HTTP Caching with Cache-Control Headers

For client-side caching, APIs should return HTTP caching headers.

📌 Example: Setting Cache Headers in Spring Boot

import org.springframework.web.bind.annotation.*;

import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @GetMapping
    public ResponseEntity<List<Product>> getProducts() {
        List<Product> products = List.of(new Product(1, "Laptop"), new Product(2, "Phone"));

        return ResponseEntity.ok()
                .cacheControl(CacheControl.maxAge(3600, TimeUnit.SECONDS)) // Cache for 1 hour
                .body(products);
    }
}

📌 Now, browsers will cache responses and reduce unnecessary API calls.

🔹 Best Practices for REST API Caching

✅ Use @Cacheable for frequently requested data (e.g., products, users, orders).
 ✅ Set cache expiration time (@CacheEvict) to avoid stale data.
 ✅ Use Redis for high-performance caching in distributed applications.
 ✅ Leverage HTTP headers (Cache-Control, ETag) for client-side caching.
 ✅ Invalidate cache on data updates (e.g., after POST or PUT operations).

📌 Example: Clearing Cache When Data Changes (@CacheEvict)

@CacheEvict(value = "products", allEntries = true)
public void addNewProduct(Product product) {
    productRepository.save(product);
}

🚀 This ensures updated data is fetched from the database after changes!

🔹 Summary: Why Use Caching in REST APIs?

🚀 Final Thoughts

Caching improves REST API performance, reduces latency, and optimizes server resources. By implementing Redis caching, HTTP caching headers, and Spring Boot caching annotations, developers can build highly scalable and efficient APIs.

💡 Want to improve API performance? Start caching responses today! 🚀