Caching Mechanism Integration With Spring Boot

🚀 Introduction to Caching in Spring Boot
In modern software development, application performance and scalability are critical. As applications grow in complexity and handle more data, repeated computations and database calls can become significant bottlenecks. This is where caching comes into play.

🧠 What Is Caching?
Caching is a technique used to store the results of expensive operations—such as database queries, API calls, or complex computations—in a temporary storage (cache), so that future requests for the same data can be served much faster.

Think of it like this: rather than asking the same question over and over again and waiting for the answer, you write the answer down the first time and just read it the next time.

💡Caching in improving the application's performance?

Without caching:

• Each request might trigger a database query, increasing load and response time.
• Complex operations are repeated unnecessarily.
• Scalability suffers under heavy traffic.

With caching:

• The response time significantly decreases.
• Database load is reduced.
• System performance and throughput improve.

Conclusively,the application becomes more scalable and resilient under load.

🧩 Caching in Spring Boot
Spring Boot provides a robust and easy-to-integrate caching abstraction that works seamlessly with various caching providers (like EhCache, Redis, Caffeine, etc.).
With just a few annotations and minimal configuration, you can enable powerful caching capabilities in your application.

Spring’s caching abstraction and its annotations:

Supports method-level/service level caching using simple annotations like @Cacheable, @CachePut, and @CacheEvict.

Integrates well with both in-memory and distributed caches.

Allows fine-grained control over what to cache and when to invalidate.

Code-Level Caching Implementation

1. Add Dependencies @pom.xml file class

<!-- Spring Boot Starter with Cache -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<!-- Optional: Ehcache (or use Caffeine, Redis, etc.) -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

1. Enabling Caching Annotation at Main Class

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

1. Caching Annotation at Service Layer

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @Cacheable("products")
    public List<Product> getAllProducts() {
        simulateSlowService(); // Simulates slow DB/API
        return productRepository.findAll();
    }

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

    private void simulateSlowService() {
        try {
            Thread.sleep(3000L); // Delay to simulate slow response
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }
}

Spring Boot Caching Annotations