Advanced Caching Techniques in Spring

Caching is an essential technique for improving application performance by storing frequently accessed data. Spring Framework offers a robust caching abstraction that simplifies cache management. In this post, we'll explore advanced caching techniques in Spring, including cacheable methods, cache eviction, and cache management.

1. Setting Up Caching in Spring

To get started, ensure you have the following dependencies in your pom.xml (for Maven users):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Enable caching in your Spring Boot application by adding the @EnableCaching annotation to your main application class:


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

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

2. Using @Cacheable Annotation

The @Cacheable annotation indicates that the result of a method call should be cached. Here’s an example:


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

@Service
public class UserService {

    @Cacheable("users")
    public User getUserById(Long id) {
        // Simulate a slow service call
        simulateSlowService();
        return findUserById(id);
    }

    private void simulateSlowService() {
        try {
            Thread.sleep(3000); // Simulate delay
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    
    private User findUserById(Long id) {
        // Fetch user from database
        return new User(id, "User " + id);
    }
}

In the example above, the first time getUserById is called with a specific ID, the result will be cached. Subsequent calls with the same ID will return the cached result instantly.

3. Configuring Cache Manager

You can configure a cache manager in your Spring configuration. Here’s an example using an in-memory cache (Caffeine):


import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        return new CaffeineCacheManager("users", Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .maximumSize(100));
    }
}

4. Evicting Cached Data with @CacheEvict

You can remove cached data using the @CacheEvict annotation. Here’s how you can use it:


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

@Service
public class UserService {

    @CacheEvict(value = "users", key = "#id")
    public void updateUser(Long id, User user) {
        // Update user logic
    }
}

In the example above, the cache for the user with the given ID is evicted whenever the updateUser method is called.

5. Using @CachePut to Update Cache

If you want to update the cache without evicting it, use the @CachePut annotation:


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

@Service
public class UserService {

    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        // Update the user in the database
        return user;
    }
}

6. Viewing Cached Data

To view the cached data, you can create a method to retrieve it from the cache:


import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Service;

@Service
public class CacheService {
    private final CacheManager cacheManager;

    public CacheService(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    public User getCachedUser(Long id) {
        Cache cache = cacheManager.getCache("users");
        return cache.get(id, User.class);
    }
}


Comments

Post a Comment

Popular posts from this blog

How to Run Python Script in PM2 Server

 To run your Flask app with PM2, follow these steps: Navigate to your project directory : Open your terminal and navigate to the directory containing your Flask app. cd path/to/flask_app Start your Flask app with PM2 : Use the following command to start your app with PM2. You need to specify the Python interpreter and the path to your app.py file. pm2 start app.py --interpreter python3 --name flask_app Replace python3 with your specific Python version if needed. Configure PM2 to run on startup (optional but recommended): To ensure PM2 restarts your app after a server reboot, you can set it up to run on startup with: pm2 startup Follow the instructions that PM2 provides after running this command. Save the PM2 process list : Save the current process list so that PM2 can restore it on reboot: pm2 save Check the status of your app : You can check the status of your Flask app using: pm2 list View logs : To see the logs for your Flask app, you can use: pm2 logs flask_app Now your...
Read more

Handling Performance Bottlenecks in Spring Applications

Problem: Many developers encounter performance bottlenecks in their Spring applications due to inefficient database queries, improper caching, and suboptimal resource management. These bottlenecks can lead to slow response times and a poor user experience. Solution: This blog post explores strategies for identifying and resolving performance bottlenecks in Spring applications. 1. Profiling and Monitoring We can use tools like Spring Boot Actuator, VisualVM, or JProfiler for profiling Spring applications. Sample : Example configuration to enable Spring Boot Actuator: @SpringBootApplication public class MyApplication { public static void main (String[] args) { SpringApplication.run(MyApplication.class, args); } } 2. Optimizing Database Queries W riting efficient SQL queries and using pagination to handle large datasets. Sample : Example of using pagination with Spring Data JPA: @Repository public interface UserRepository extends JpaRepository <User, Lon...
Read more

Retry in SprinBoot Application

In a Spring Boot application, you can use the @Retryable annotation to automatically retry a failed operation. The @Retryable annotation can be applied to a method and can be used to specify the conditions under which the method should be retried. For example: @Retryable (value = { MyException. class }, maxAttempts = 3 , backoff = @Backoff (delay = 1000 )) public void myMethod () throws MyException { // method body } In this example, the myMethod() method will be retried if it throws an exception of type MyException. The method will be retried up to a maximum of 3 times, with a delay of 1000 milliseconds between each retry. You can also specify the @Recover annotation on a method to provide a recovery action for a failed operation. The @Recover method should have the same signature as the retryable method, except that it should have an additional parameter of type Throwable to receive the exception that caused the failure. For example: @Recover public void recover (MyE...
Read more