Spring Boot and Redis: sessions and caching?

Question

Accepted Answer

**Redis** — an in-memory distributed key-value store. Spring Boot uses it for **sessions, caching, and queues**. **Simple analogy:** Redis is like a shared fridge for all office employees. Everyone takes and puts food. Fast, accessible to all, but you need to share space. Or think of it as a whiteboard in a meeting room: anyone can write and read instantly, but the board is finite and everything disappears when the power goes out (data lives in memory only, unless you enable persistence). **Why it matters:** When you run multiple instances of your app behind a load balancer, each instance needs access to the same session data. Storing sessions in-memory on one instance means user X hits server A, logs in, then gets routed to server B and is logged out. Redis solves this by providing a shared, fast data store that all instances read from. The same principle applies to caching — avoiding redundant database queries across all instances. **1. Redis for sessions:** ```yaml # application.yml spring: session: store-type: redis timeout: 30m redis: flush-mode: on_save namespace: spring:session data: redis: host: localhost port: 6379 password: ${REDIS_PASSWORD} timeout: 2000ms ``` Now HTTP sessions are stored in Redis, and any server in the cluster can read them. **2. Redis as cache:** ```java @Configuration @EnableCaching public class RedisCacheConfig { @Bean public RedisCacheManager cacheManager(RedisConnectionFactory factory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofMinutes(30)) .serializeValuesWith( RedisSerializationContext.SerializationPair.fromSerializer( new GenericJackson2JsonRedisSerializer() ) ); Map cacheConfigs = Map.of( "users", config.entryTtl(Duration.ofHours(1)), "products", config.entryTtl(Duration.ofMinutes(10)), "sessions", config.entryTtl(Duration.ofMinutes(30)) ); return RedisCacheManager.builder(factory) .cacheDefaults(config) .withInitialCacheConfigurations(cacheConfigs) .build(); } } @Cacheable(value = "users", key = "#id") public User findById(Long id) { ... } @CacheEvict(value = "users", key = "#id") public void deleteUser(Long id) { ... } ``` **3. Redis for Rate Limiting:** ```java public boolean isAllowed(String userId, int maxRequests, Duration window) { String key = "rate:" + userId; Long count = redisTemplate.opsForValue().increment(key); if (count == 1) { redisTemplate.expire(key, window); } return count <= maxRequests; } ``` **4. Redis Pub/Sub:** ```java @Bean public RedisMessageListenerContainer container(RedisConnectionFactory factory) { RedisMessageListenerContainer container = new RedisMessageListenerContainer(); container.setConnectionFactory(factory); container.addMessageListener((message, pattern) -> { System.out.println("Received: " + new String(message.getBody())); }, new PatternTopic("events.*")); return container; } ``` **Production pitfalls:** - **Redis single point of failure** — use Redis Sentinel or Redis Cluster for HA. - **Cache stampede** — when a cache key expires and 1000 requests hit the database simultaneously. Use `@Cacheable` with `sync = true` to prevent this. - **Memory limits** — set `maxmemory-policy` (e.g., `allkeys-lru`) to evict old keys when Redis runs out of memory. - **Not setting TTL** — keys without expiry accumulate forever and consume memory.

Java: Spring Boot and Redis: sessions and caching?