Master Spring Cache Annotations: @EnableCaching, @Cacheable, @CachePut, @CacheEvict Explained

Background

Cache is a common technique to reduce database read pressure and improve query performance. It is used for data that changes infrequently but is accessed frequently, such as configuration, product, or user information. Typical usage reads from DB once, stores in cache with TTL, and synchronizes on updates or deletes.

Instead of writing custom cache annotations, Spring already provides powerful cache annotation support.

Spring Cache Annotations

Key annotations:

@EnableCaching : Enables cache support; must be placed on a configuration class.

@Cacheable : Marks a method or class as cacheable; caches the method result. Attributes: value / cacheNames (cache name), key (SpEL key), condition (SpEL condition).

@CachePut : Executes the method and updates the cache with the result; used for cache synchronization.

@CacheEvict : Removes entries from the cache, typically on delete operations.

Engineering Practice

3.1 Add Dependency

Include spring-boot-starter-data-redis in the Maven pom.

<project>
  <modelVersion>4.0.0</modelVersion>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <version>${spring.boot.version}</version>
    </dependency>
    ...
  </dependencies>
</project>

3.2 Core Code

Cache configuration class:

package com.java.demo.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.support.NoOpCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import java.time.Duration;

@Configuration
@EnableCaching
public class RedisCacheConfig {

    @Value("${cache.enable:false}")
    private Boolean cacheEnable;

    @Value("${cache.ttl:120}")
    private Long cacheTtl;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        if (cacheEnable) {
            RedisCacheConfiguration config = instanceConfig();
            return RedisCacheManager.builder(redisConnectionFactory)
                    .cacheDefaults(config)
                    .transactionAware()
                    .build();
        }
        return new NoOpCacheManager();
    }

    private RedisCacheConfiguration instanceConfig() {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(cacheTtl))
                .disableCachingNullValues();
    }
}

Entity class:

public class User implements Serializable {
    private String userId;
    private String userName;
    // getters, setters, toString
}

Service interface and implementation with cache annotations:

public interface UserService {
    User getUserById(String userId);
    User updateUser(User user);
    void deleteUser(String userId);
}

@Component
public class UserServiceImpl implements UserService {

    @Cacheable(cacheNames = "users", key = "#userId")
    public User getUserById(String userId) { /* ... */ }

    @CachePut(cacheNames = "users", key = "#user.userId")
    public User updateUser(User user) { return user; }

    @CacheEvict(cacheNames = "users", key = "#userId")
    public void deleteUser(String userId) { /* ... */ }
}

Application entry point:

@SpringBootApplication
@ComponentScan("com.java.demo")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
}

Cache related properties (spring.redis.* and custom cache.enable/ttl) are set in application.properties.

3.3 Test Cases

JUnit test demonstrates first read (cache miss), second read (cache hit), update (CachePut), and delete (CacheEvict).

public class CacheTest {
    @Autowired
    private UserService userService;

    @Test
    public void testCache() {
        logger.info("1.user:{}", userService.getUserById("123"));
        logger.info("2.user:{}", userService.getUserById("123"));
        userService.updateUser(new User("123","zhang hua"));
        logger.info("3.user:{}", userService.getUserById("123"));
        userService.deleteUser("123");
        logger.info("test finish!");
    }
}

Images illustrate cache miss, hit, update, and eviction processes.

Conclusion

Using Spring's @EnableCaching and related annotations decouples cache logic from business code, making it cleaner and more efficient. However, @EnableCaching does not expose a cache TTL attribute; TTL must be configured via CacheManager.