Redis Core Concepts: Data Structures, TTLs, and Persistence

# Basic set/get
SET user:1001:name "Alicia Keys"
GET user:1001:name
# → "Alicia Keys"
 
# Set with expiry in one atomic command
SET session:abc123 "{\"userId\":1001}" EX 1800
 
# Atomic counters — no read-modify-write race
INCR page:home:views
INCRBY inventory:sku-42 -5
INCRBYFLOAT wallet:1001:balance 19.99
 
# Conditional writes — the basis of distributed locks
SET lock:order:5001 "worker-7" NX PX 10000

@Service
public class ProductCacheService {
 
    private final StringRedisTemplate redisTemplate;
 
    public ProductCacheService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
 
    public void cacheProduct(String productId, String json) {
        redisTemplate.opsForValue()
            .set("product:" + productId, json, Duration.ofMinutes(15));
    }
 
    public Optional<String> getCachedProduct(String productId) {
        return Optional.ofNullable(
            redisTemplate.opsForValue().get("product:" + productId));
    }
 
    public long incrementViewCount(String productId) {
        return redisTemplate.opsForValue()
            .increment("product:" + productId + ":views");
    }
}

HSET user:1001 name "Alicia Keys" email "alicia@example.com" plan "pro"
HGET user:1001 email
HGETALL user:1001
HINCRBY user:1001 loginCount 1
HDEL user:1001 plan

@Service
public class UserProfileCacheService {
 
    private final RedisTemplate<String, Object> redisTemplate;
 
    public void cacheProfile(String userId, Map<String, Object> fields) {
        String key = "user:" + userId;
        redisTemplate.opsForHash().putAll(key, fields);
        redisTemplate.expire(key, Duration.ofHours(6));
    }
 
    public Object getField(String userId, String field) {
        return redisTemplate.opsForHash().get("user:" + userId, field);
    }
 
    public Long incrementLoginCount(String userId) {
        return redisTemplate.opsForHash()
            .increment("user:" + userId, "loginCount", 1);
    }
}

LPUSH notifications:1001 "New comment on your post"
RPUSH activity:feed:1001 "logged in"
LRANGE activity:feed:1001 0 9    # latest 10 items
LTRIM activity:feed:1001 0 99    # keep only the newest 100
BLPOP queue:jobs 5                # blocking pop, 5s timeout

public void pushRecentActivity(String userId, String activity) {
    String key = "activity:feed:" + userId;
    redisTemplate.opsForList().leftPush(key, activity);
    redisTemplate.opsForList().trim(key, 0, 99);   // cap the feed size
    redisTemplate.expire(key, Duration.ofDays(30));
}
 
public List<Object> getRecentActivity(String userId, int count) {
    return redisTemplate.opsForList().range("activity:feed:" + userId, 0, count - 1);
}

# Set — membership and set algebra
SADD user:1001:roles "admin" "billing"
SISMEMBER user:1001:roles "admin"      # → 1
SINTER user:1001:roles user:1002:roles  # shared roles
 
# Sorted set — leaderboard
ZADD leaderboard:global 15420 "player:88"
ZADD leaderboard:global 18990 "player:12"
ZREVRANGE leaderboard:global 0 9 WITHSCORES   # top 10
ZRANK leaderboard:global "player:88"           # rank of a specific player
ZINCRBY leaderboard:global 100 "player:88"     # atomic score bump

@Service
public class LeaderboardService {
 
    private final ZSetOperations<String, String> zSetOps;
 
    public LeaderboardService(RedisTemplate<String, String> redisTemplate) {
        this.zSetOps = redisTemplate.opsForZSet();
    }
 
    public void recordScore(String playerId, double score) {
        zSetOps.add("leaderboard:global", playerId, score);
    }
 
    public Set<ZSetOperations.TypedTuple<String>> topPlayers(int count) {
        return zSetOps.reverseRangeWithScores("leaderboard:global", 0, count - 1);
    }
 
    public Long rankOf(String playerId) {
        Long rank = zSetOps.reverseRank("leaderboard:global", playerId);
        return rank == null ? null : rank + 1;  // 0-indexed → human rank
    }
}

EXPIRE session:abc123 1800         # set TTL in seconds
PEXPIRE lock:order:5001 10000      # set TTL in milliseconds
TTL session:abc123                 # remaining seconds (-1 = no TTL, -2 = doesn't exist)
PERSIST session:abc123             # remove TTL, key lives forever
EXPIREAT session:abc123 1755200000 # expire at a specific Unix timestamp

// Spring Data Redis — TTL-safe update pattern
public void refreshSessionData(String sessionId, String newPayload) {
    redisTemplate.opsForValue().set(
        "session:" + sessionId,
        newPayload,
        Duration.ofMinutes(30)   // always re-assert TTL explicitly
    );
}

# redis.conf or CONFIG SET
maxmemory 4gb
maxmemory-policy allkeys-lru

# redis.conf — save if N changes happen within M seconds
save 900 1        # after 900s if at least 1 key changed
save 300 10        # after 300s if at least 10 keys changed
save 60 10000       # after 60s if at least 10000 keys changed
 
dbfilename dump.rdb
dir /var/lib/redis

# redis.conf
appendonly yes
appendfsync everysec   # fsync once per second — default, good balance
# appendfsync always   # fsync every write — safest, slowest
# appendfsync no       # let the OS decide — fastest, least safe

# application.yml
spring:
  data:
    redis:
      host: redis.internal
      port: 6379
      password: ${REDIS_PASSWORD}
      timeout: 2000ms
      lettuce:
        pool:
          max-active: 16
          max-idle: 8
          min-idle: 2
        shutdown-timeout: 200ms

@Configuration
public class RedisConfig {
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}