Spring Data Redis - Quick Reference

Full Reference: See advanced.md for hash/list/set operations, sorted sets, @RedisHash repository pattern, pub/sub configuration, and distributed lock patterns.

Deep Knowledge: Use mcp__documentation__fetch_docs with technology: spring-data-redis for comprehensive documentation.

Dependencies

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

Configuration

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: ${REDIS_PASSWORD:}
      database: 0
      timeout: 2000ms
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 2

  cache:
    type: redis
    redis:
      time-to-live: 3600000  # 1 hour
      cache-null-values: false
      key-prefix: "myapp:"

RedisTemplate Configuration

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        Jackson2JsonRedisSerializer<Object> jsonSerializer =
            new Jackson2JsonRedisSerializer<>(Object.class);

        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

Basic String Operations

@Service
@RequiredArgsConstructor
public class RedisService {

    private final RedisTemplate<String, Object> redisTemplate;

    public void set(String key, Object value, Duration ttl) {
        redisTemplate.opsForValue().set(key, value, ttl);
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public boolean setIfAbsent(String key, Object value, Duration ttl) {
        return Boolean.TRUE.equals(
            redisTemplate.opsForValue().setIfAbsent(key, value, ttl));
    }

    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    public void delete(String key) {
        redisTemplate.delete(key);
    }
}

Spring Cache Integration

@SpringBootApplication
@EnableCaching
public class Application { }

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .disableCachingNullValues()
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));

        Map<String, RedisCacheConfiguration> cacheConfigs = Map.of(
            "users", defaultConfig.entryTtl(Duration.ofHours(1)),
            "products", defaultConfig.entryTtl(Duration.ofMinutes(15))
        );

        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(cacheConfigs)
            .build();
    }
}

Cache Annotations

@Service
public class UserService {

    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        return userRepository.save(user);
    }

    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }

    @CacheEvict(value = "users", allEntries = true)
    public void clearUserCache() { }
}

When NOT to Use This Skill

Raw Redis commands - Use redis skill for low-level operations
Non-Spring applications - Use Jedis or Lettuce directly
Primary database - Redis is for caching, not primary storage
Complex queries - Use SQL databases for complex queries

Anti-Patterns

| Anti-Pattern | Problem | Solution | |--------------|---------|----------| | No TTL on cached data | Memory exhaustion | Always set expiration | | Large objects in cache | Memory pressure | Keep values small | | Cache stampede | Thundering herd | Use distributed locks | | @Cacheable on void methods | No effect | Only cache return values | | Caching mutable objects | Stale data | Cache immutable or clone | | No connection pooling | Connection exhaustion | Configure Lettuce pool |

Quick Troubleshooting

| Problem | Diagnostic | Fix | |---------|------------|-----| | Connection refused | Check Redis running | Start Redis, check host/port | | Cache not working | Check @EnableCaching | Add annotation, verify AOP proxy | | Serialization error | Check object type | Configure proper serializer | | Memory issues | redis-cli INFO memory | Set maxmemory, eviction policy |

Production Checklist

[ ] Connection pool configured
[ ] TTL set on all keys
[ ] Serializers configured
[ ] Cluster/Sentinel for HA
[ ] Memory limits set
[ ] Eviction policy configured
[ ] Monitoring enabled
[ ] Error handling for failures

Reference Documentation

Spring Data Redis Reference