Yichun Zhao's blog

SpringBoot: Redis: Cache

Yichun Zhao's photo
Yichun Zhao
·

3 min read

The @Cacheable annotation in Spring is a powerful tool for adding caching to your application. When using Redis as a remote cache, @Cacheable can be used to reduce the number of database hits by storing and retrieving data from the Redis cache, thereby improving the performance of your application.

How @Cacheable Works

  • Basic Concept: When a method annotated with @Cacheable is called, Spring checks if the result of that method call is already in the cache. If it is, Spring returns the cached result instead of executing the method. If not, it executes the method, caches the result, and then returns it.

  • Cache Key: The key for the cache entry is automatically generated by Spring based on the method parameters. You can also specify a custom key generation strategy.

  • Cache Name: The cache to use is specified in the @Cacheable annotation. This name should correspond to a cache configuration that you've set up, which in your case would be linked to Redis.

Example: Using @Cacheable with Redis

Let's consider a simple example where you have a service that retrieves user details from a database, and you want to cache these details using Redis.

Step 1: Add Dependencies

Include Spring Boot Starter for Data Redis and any other necessary dependencies:

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

Step 2: Configure Redis

In application.properties or application.yml, configure the Redis connection:

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

Step 3: Enable Caching

Enable caching in your Spring Boot application:

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

@SpringBootApplication
@EnableCaching
public class MyApp {

    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

Step 4: Create a Cachable Service

Assuming you have a UserService that fetches user details:

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

@Service
public class UserService {

    @Cacheable(value = "users", key = "#userId")
    public User getUserById(String userId) {
        // Method to fetch user from the database
        return database.getUserById(userId);
    }
}

In this example, when getUserById is called with a userId, Spring checks the cache named "users" for a key that matches the userId. If a match is found, the cached User object is returned. Otherwise, the method executes, retrieves the User from the database, caches the result, and returns it.

Considerations

  • Cache Eviction: To maintain cache consistency, use @CacheEvict to clear cache entries when the underlying data changes.
  • Cache Key: Be mindful of the cache key. Incorrect keys can lead to cache misses.
  • Cache Configuration: Further customize cache behavior (e.g., TTL, max size) in your cache configuration.
  • Error Handling: Implement appropriate error handling, especially for cache communication issues.
  • Serialization: Ensure that your objects (like User in the example) are serializable, as they need to be serialized to be stored in Redis.

This is a basic example, and in a real-world application, you might need to address more complex scenarios and configurations, especially considering the nature of distributed caching and its implications on your application's design and performance.

SpringbootRedis