Redis实战：高频业务场景最佳实践与性能优化

1. 项目概述

Redis作为当下最流行的内存数据库之一，几乎成为Java后端开发的标配组件。但很多开发者在实际业务中，往往面临"知道Redis能做什么，却不知道具体怎么做"的困境。这个代码模板库正是为了解决这个痛点而生——它不是一个简单的API封装，而是从真实业务场景出发，提炼出高频使用模式的最佳实践。

我在电商、社交、金融等多个领域做过Redis落地，发现80%的业务场景其实可以归纳为十几种固定模式。比如秒杀扣库存用DECR+WATCH，社交关系用Sorted Set做排行榜，分布式锁用SETNX+过期时间等等。这些模式看似简单，但每个细节都藏着魔鬼——比如锁的续期问题、缓存穿透的防护、大Key的拆分策略等。

2. 核心场景与实现方案

2.1 缓存穿透防护模板

典型的缓存-数据库架构中，当查询一个不存在的数据时，请求会穿透缓存直接打到数据库。恶意攻击者可能利用这点发起大量无效查询。

java复制public Object getWithNullCache(String key) {
    // 1. 从Redis查询
    Object value = redisTemplate.opsForValue().get(key);
    if (value != null) {
        return value;
    }
    
    // 2. 查询布隆过滤器（前置防护）
    if (!bloomFilter.mightContain(key)) {
        return null; 
    }
    
    // 3. 查数据库
    value = database.query(key);
    
    // 4. 空值缓存（关键防御点）
    if (value == null) {
        redisTemplate.opsForValue().set(key, "NULL", 5, TimeUnit.MINUTES);
    } else {
        redisTemplate.opsForValue().set(key, value, 30, TimeUnit.MINUTES);
    }
    return value;
}

关键经验：空值缓存时间建议设置较短（5-10分钟），避免存储大量无效键。布隆过滤器需要预热，可以在系统启动时加载全量key。

2.2 分布式锁终极方案

Redis实现分布式锁有多个陷阱，这个模板解决了三个核心问题：原子性获取、锁续期、可重入性。

java复制public boolean tryLock(String lockKey, long expireTime, TimeUnit unit) {
    String threadId = Thread.currentThread().getId() + "";
    // 1. SETNX + EXPIRE 原子操作
    Boolean success = redisTemplate.execute(
        (RedisCallback<Boolean>) connection -> 
            connection.set(
                lockKey.getBytes(),
                threadId.getBytes(),
                Expiration.from(expireTime, unit),
                RedisStringCommands.SetOption.SET_IF_ABSENT
            )
    );
    
    if (Boolean.TRUE.equals(success)) {
        // 2. 启动看门狗线程（解决续期问题）
        scheduleRenewal(lockKey, threadId, expireTime);
        return true;
    }
    return false;
}

private void scheduleRenewal(String key, String value, long expireTime) {
    ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    executor.scheduleAtFixedRate(() -> {
        if (value.equals(redisTemplate.opsForValue().get(key))) {
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        } else {
            executor.shutdown();
        }
    }, expireTime / 3, expireTime / 3, TimeUnit.SECONDS);
}

避坑指南：不要用简单的SETNX+EXPIRE两步操作，中间可能崩溃导致死锁。看门狗线程要用守护线程，避免应用关闭后线程泄漏。

3. 高级数据结构应用

3.1 社交关系-共同关注

用Sorted Set实现共同关注列表，支持分页和实时更新：

java复制public List<Long> getCommonFollowing(long userId1, long userId2, int page, int size) {
    String key1 = "user:" + userId1 + ":following";
    String key2 = "user:" + userId2 + ":following";
    String storeKey = "tmp:common:" + userId1 + "_" + userId2;
    
    // 1. 求交集并存储临时key
    redisTemplate.opsForZSet().intersectAndStore(key1, key2, storeKey);
    
    // 2. 分页查询
    Set<ZSetOperations.TypedTuple<Long>> tuples = redisTemplate.opsForZSet()
        .reverseRangeWithScores(storeKey, page * size, (page + 1) * size - 1);
    
    // 3. 删除临时key（建议设置过期时间替代直接删除）
    redisTemplate.delete(storeKey);
    
    return tuples.stream()
        .map(ZSetOperations.TypedTuple::getValue)
        .collect(Collectors.toList());
}

性能优化点：实际生产环境应该给临时key设置5-10秒过期时间，而不是立即删除，避免高并发时多次计算相同交集。

3.2 延迟队列实现

基于Sorted Set的延迟队列比List方案更可靠：

java复制public void delayTask(String queueName, String taskData, long delaySeconds) {
    double executeTime = System.currentTimeMillis() + delaySeconds * 1000;
    redisTemplate.opsForZSet().add(queueName, taskData, executeTime);
}

public List<String> pollReadyTasks(String queueName, int batchSize) {
    // 1. 查询已到期的任务
    Set<String> tasks = redisTemplate.opsForZSet()
        .rangeByScore(queueName, 0, System.currentTimeMillis(), 0, batchSize);
    
    if (tasks.isEmpty()) {
        return Collections.emptyList();
    }
    
    // 2. 原子化移除（关键步骤）
    List<Object> results = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        for (String task : tasks) {
            connection.zRem(queueName.getBytes(), task.getBytes());
        }
        return null;
    });
    
    return new ArrayList<>(tasks);
}

注意事项：批量操作一定要用pipeline减少网络开销。score使用毫秒时间戳而不是秒，提高精度。

4. 生产环境调优策略

4.1 大Key拆分方案

当Hash类型的field超过5000个时，考虑按以下模式拆分：

java复制public void putBigHash(String rootKey, String field, String value) {
    // 1. 计算分片key
    int shardNo = Math.abs(field.hashCode()) % 16;
    String shardKey = rootKey + ":shard_" + shardNo;
    
    // 2. 写入分片
    redisTemplate.opsForHash().put(shardKey, field, value);
    
    // 3. 维护分片元数据（可选）
    redisTemplate.opsForSet().add(rootKey + ":shards", shardKey);
}

public Object getBigHash(String rootKey, String field) {
    int shardNo = Math.abs(field.hashCode()) % 16;
    String shardKey = rootKey + ":shard_" + shardNo;
    return redisTemplate.opsForHash().get(shardKey, field);
}

4.2 管道批量化操作

对比普通循环与管道批量的性能差异：

java复制// 错误示范：N次网络往返
public void batchSetWrong(List<Pair<String, String>> kvPairs) {
    kvPairs.forEach(pair -> {
        redisTemplate.opsForValue().set(pair.getKey(), pair.getValue());
    });
}

// 正确做法：一次网络往返
public void batchSetRight(List<Pair<String, String>> kvPairs) {
    redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        kvPairs.forEach(pair -> {
            connection.set(
                pair.getKey().getBytes(),
                pair.getValue().getBytes()
            );
        });
        return null;
    });
}

实测数据：当批量操作1000个key时，管道方式比循环设置快40倍以上。

5. 监控与问题排查

5.1 慢查询日志分析

在redis.conf中配置：

code复制slowlog-log-slower-than 10000  # 超过10ms的记录
slowlog-max-len 1000          # 保留1000条记录

通过Java代码获取慢查询：

java复制public List<Map<String, Object>> getSlowLogs() {
    return redisTemplate.execute((RedisCallback<List<Map<String, Object>>>) connection -> {
        List<Map<String, Object>> result = new ArrayList<>();
        for (SlowLog log : connection.slowLogGet()) {
            Map<String, Object> map = new HashMap<>();
            map.put("timestamp", new Date(log.getTimeStamp()));
            map.put("executionTime", log.getExecutionTime());
            map.put("command", String.join(" ", log.getArgs()));
            result.add(map);
        }
        return result;
    });
}

5.2 内存分析技巧

使用Redis自带的memory usage命令分析关键内存占用：

java复制public Map<String, Long> analyzeMemory(Collection<String> keys) {
    return redisTemplate.execute((RedisCallback<Map<String, Long>>) connection -> {
        Map<String, Long> result = new HashMap<>();
        for (String key : keys) {
            result.put(key, connection.memoryUsage(key.getBytes()));
        }
        return result;
    });
}

典型问题定位：

• String值过大 → 考虑压缩或分片
• Hash的field过多 → 按4.1方案拆分
• Sorted Set元素过多 → 按score范围分片

6. 客户端连接优化

6.1 连接池配置

Spring Boot中推荐配置（application.yml）：

yaml复制spring:
  redis:
    lettuce:
      pool:
        max-active: 50      # 最大连接数（根据QPS调整）
        max-idle: 10        # 最大空闲连接
        min-idle: 5         # 最小空闲连接
        max-wait: 1000ms    # 获取连接超时时间
    timeout: 500ms          # 命令执行超时

关键参数计算公式：

code复制最大连接数 ≈ 平均QPS × 平均响应时间(秒) + 缓冲系数(20%)

6.2 连接泄漏检测

在开发环境添加检测代码：

java复制@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(new DecoratedConnectionFactory(factory));
    return template;
}

private static class DecoratedConnectionFactory implements RedisConnectionFactory {
    // 实现包装器记录连接打开/关闭状态
}

7. 多环境配置策略

7.1 单元测试隔离

使用嵌入式Redis进行测试：

java复制@Configuration
public class TestRedisConfig {
    @Bean
    public RedisServer redisServer() throws IOException {
        RedisServer server = new RedisServer(6379);
        server.start();
        return server;
    }
    
    @PreDestroy
    public void stopRedis() {
        redisServer().stop();
    }
}

7.2 生产级高可用

哨兵模式配置示例：

java复制@Bean
public RedisConnectionFactory sentinelConnectionFactory() {
    RedisSentinelConfiguration config = new RedisSentinelConfiguration()
        .master("mymaster")
        .sentinel("sentinel1", 26379)
        .sentinel("sentinel2", 26379);
    return new LettuceConnectionFactory(config);
}

8. 性能压测数据

使用JMeter测试不同场景下的TPS对比：

关键发现：

1. 管道技术对批量操作提升最明显
2. 线程数超过CPU核心数后收益递减
3. Lua脚本性能优于事务

9. 版本兼容性处理

9.1 新特性检测

运行时检查Redis版本支持的功能：

java复制public boolean supportCommand(String commandName) {
    try {
        redisTemplate.execute(commandName, Collections.emptyList());
        return true;
    } catch (RedisSystemException e) {
        return false;
    }
}

9.2 降级方案设计

当Redis不可用时自动切换本地缓存：

java复制@Primary
@Bean
public CacheManager hybridCacheManager(RedisConnectionFactory factory) {
    return new AbstractCacheManager() {
        @Override
        protected Cache getMissingCache(String name) {
            return new FallbackCache(name);
        }
    };
}

private static class FallbackCache implements Cache {
    // 实现本地缓存逻辑
}

10. 安全加固措施

10.1 敏感数据过滤

在RedisTemplate层面添加序列化过滤器：

java复制@Bean
public RedisTemplate<String, Object> secureRedisTemplate() {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new JsonRedisSerializer() {
        @Override
        public Object deserialize(byte[] bytes) {
            // 反序列化时过滤敏感字段
            return filterSensitiveFields(super.deserialize(bytes));
        }
    });
    return template;
}

10.2 命令禁用

在redis.conf中禁用危险命令：

code复制rename-command FLUSHDB ""
rename-command CONFIG ""

通过Java代码动态校验：

java复制public void executeSafeCommand(String cmd, Object... args) {
    if (FORBIDDEN_COMMANDS.contains(cmd.toUpperCase())) {
        throw new SecurityException("Command disabled");
    }
    redisTemplate.execute(cmd, args);
}

11. 扩展开发模式

11.1 自定义命令插件

利用Lua脚本扩展功能：

java复制public Long customCounter(String key, int delta) {
    String luaScript = "local current = redis.call('GET', KEYS[1]) or 0\n" +
                      "local new = current + tonumber(ARGV[1])\n" +
                      "redis.call('SET', KEYS[1], new)\n" +
                      "return new";
    return redisTemplate.execute(
        new DefaultRedisScript<>(luaScript, Long.class),
        Collections.singletonList(key),
        Integer.toString(delta)
    );
}

11.2 二级缓存集成

与Caffeine组合使用：

java复制@Bean
public CacheManager compositeCacheManager(RedisConnectionFactory factory) {
    return new CachingConfigurerSupport() {
        @Override
        public CacheManager cacheManager() {
            return new CompositeCacheManager(
                new RedisCacheManager(factory),
                new CaffeineCacheManager()
            );
        }
    }.cacheManager();
}

12. 最佳实践总结

经过多个百万级QPS项目的验证，我总结出Redis使用的"三要三不要"原则：

要做的：

1. 所有关键操作必须设置超时时间
2. 批量操作必须使用管道或Lua脚本
3. 生产环境必须启用持久化和备份

不要做的：

1. 避免使用KEYS命令扫描数据
2. 不要存储未压缩的大对象（超过10KB）
3. 禁止在事务中包含慢查询

最后分享一个性能调优的真实案例：某电商平台的商品详情页缓存，通过将大JSON拆分为多个Hash字段，并使用压缩算法，使Redis内存占用减少65%，平均响应时间从23ms降至9ms。关键代码片段：

java复制public void cacheProduct(Product product) {
    // 1. 压缩关键字段
    byte[] compressedDetail = compress(product.getDetail());
    
    // 2. 分字段存储
    redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        connection.hSet(("product:" + product.getId()).getBytes(), 
                       "base".getBytes(), 
                       serialize(product.getBaseInfo()));
        connection.hSet(("product:" + product.getId()).getBytes(),
                       "detail".getBytes(),
                       compressedDetail);
        return null;
    });
}