Redis 安装配置与 10 大业务场景实战

@Configuration
public class RedisConfig {

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

        // Key 使用 String 序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // Value 使用 JSON 序列化
        Jackson2JsonRedisSerializer<Object> jsonSerializer =
                new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.activateDefaultTyping(
                om.getPolymorphicTypeValidator(),
                ObjectMapper.DefaultTyping.NON_FINAL);
        jsonSerializer.setObjectMapper(om);

        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // ---- String 操作 ----

    /** 设置缓存（带过期时间） */
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /** 获取缓存 */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /** 自增（计数器） */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    // ---- Hash 操作 ----

    /** 设置 Hash 字段 */
    public void hSet(String key, String field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    /** 获取 Hash 全部字段 */
    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /** Hash 字段自增 */
    public Long hIncr(String key, String field, long delta) {
        return redisTemplate.opsForHash().increment(key, field, delta);
    }

    // ---- Sorted Set 操作 ----

    /** 添加排行榜分数 */
    public Boolean zAdd(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /** 获取排行榜 Top N */
    public Set<Object> zRevRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    // ---- 通用操作 ----

    /** 设置过期时间 */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /** 删除 key */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /** 判断 key 是否存在 */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

// 缓存读取模式（Cache-Aside）
public User getUser(Long userId) {
    String key = "user:" + userId;

    // 1. 先查缓存
    User user = (User) redisTemplate.opsForValue().get(key);
    if (user != null) {
        return user;
    }

    // 2. 缓存未命中，查数据库
    user = userMapper.selectById(userId);
    if (user != null) {
        // 3. 写入缓存，设置过期时间（防止缓存雪崩加随机值）
        int expire = 3600 + new Random().nextInt(600);
        redisTemplate.opsForValue().set(key, user, expire, TimeUnit.SECONDS);
    }
    return user;
}

// SpringBoot 排行榜示例
public List<RankItem> getTopN(String rankKey, int n) {
    Set<ZSetOperations.TypedTuple<Object>> tuples =
            redisTemplate.opsForZSet().reverseRangeWithScores(rankKey, 0, n - 1);
    List<RankItem> result = new ArrayList<>();
    int rank = 1;
    for (ZSetOperations.TypedTuple<Object> tuple : tuples) {
        result.add(new RankItem(rank++, tuple.getValue().toString(),
                tuple.getScore()));
    }
    return result;
}

// SpringBoot 简单限流示例
public boolean isAllowed(String clientId, int maxRequests, int windowSeconds) {
    String key = "rate:" + clientId;
    Long count = redisTemplate.opsForValue().increment(key);
    if (count == 1) {
        // 首次请求，设置过期时间
        redisTemplate.expire(key, windowSeconds, TimeUnit.SECONDS);
    }
    return count <= maxRequests;
}

// 启用 Redis Session
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800)
@Configuration
public class SessionConfig {
}

// Redisson 分布式锁示例
@Autowired
private RedissonClient redissonClient;

public void deductStock(String productId) {
    RLock lock = redissonClient.getLock("lock:stock:" + productId);
    try {
        // 尝试加锁：等待 5 秒，锁自动释放时间 10 秒
        if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
            // 执行减库存逻辑
            int stock = getStock(productId);
            if (stock > 0) {
                updateStock(productId, stock - 1);
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// SpringBoot 最新列表示例
public void addToTimeline(String userId, String postId) {
    String key = "timeline:" + userId;
    redisTemplate.opsForList().leftPush(key, postId);
    // 只保留最新 100 条
    redisTemplate.opsForList().trim(key, 0, 99);
}

public List<Object> getTimeline(String userId, int page, int size) {
    String key = "timeline:" + userId;
    long start = (long) page * size;
    long end = start + size - 1;
    return redisTemplate.opsForList().range(key, start, end);
}