## 1. 本地缓存方案
– 在应用服务器上使用本地缓存（如Guava Cache、Caffeine等）
– 减轻Redis的访问压力
– 适合读多写少的场景

## 2. Key分片方案
– 将热Key分散到多个Key中
– 如将user:1001:info分散为user:1001:info:1、user:1001:info:2等
– 适合热点数据可以分片的场景

## 3. 读写分离方案
– 使用主从复制，将读请求分散到多个从节点
– 主节点负责写操作，从节点负责读操作
– 适合读多写少的场景

## 4. 集群扩容方案
– 增加Redis节点数量，分散负载
– 适合整体负载较高的场景

## 5. 限流方案
– 对热Key的访问进行限流
– 避免Redis被突发流量压垮
– 适合流量不可控的场景

## 1. 使用Redis自带命令监控
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 info commandstats
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 –latency-history

## 2. 使用Prometheus监控
# 配置Prometheus监控Redis
– job_name: ‘redis’
static_configs:
– targets: [‘192.168.1.100:9121’]

## 3. 使用Grafana可视化
# 配置Grafana面板，监控Redis命令执行次数和延迟

## 4. 编写监控脚本
#!/bin/bash
# hotkey_monitor.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

REDIS_CLI=”/redis/app/bin/redis-cli”
HOST=”192.168.1.100″
PORT=”6379″
PASSWORD=”fgedu@2026″
THRESHOLD=1000

# 检测热Key
COMMANDSTATS=$($REDIS_CLI -h $HOST -p $PORT -a $PASSWORD info commandstats)

# 发送告警
if echo “$COMMANDSTATS” | grep -E “calls=([0-9]+)” | awk ‘{if($2 > $THRESHOLD) print $0}’; then
echo “发现热Key，请及时处理”
fi

学习交流加群风哥QQ113257174

Part03-生产环境项目实施方案

3.1 热Key检测实施

## 1. 使用Redis命令统计
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 info commandstats

## 2. 使用Redis慢查询日志
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 config set slowlog-log-slower-than 0
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 slowlog get

## 3. 使用Redis监控工具
# 安装redis_exporter
$ wget https://github.com/oliver006/redis_exporter/releases/download/v1.37.0/redis_exporter-v1.37.0.linux-amd64.tar.gz
$ tar -xzf redis_exporter-v1.37.0.linux-amd64.tar.gz
$ cd redis_exporter-v1.37.0.linux-amd64
$ ./redis_exporter –redis.addr=192.168.1.100:6379 –redis.password=fgedu@2026

## 4. 编写热Key检测脚本
#!/bin/bash
# hotkey_detection.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

REDIS_CLI=”/redis/app/bin/redis-cli”
HOST=”192.168.1.100″
PORT=”6379″
PASSWORD=”fgedu@2026″

# 检测命令执行次数
$REDIS_CLI -h $HOST -p $PORT -a $PASSWORD info commandstats > commandstats.txt

# 分析热Key
cat commandstats.txt | grep -E “cmdstat_|calls”

## 1. 本地缓存方案
# 在应用代码中使用本地缓存
// Java示例（使用Caffeine）
Cache cache = Caffeine.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES)
.maximumSize(1000)
.build();

// 获取数据
String value = cache.getIfPresent(“key”);
if (value == null) {
value = redisTemplate.opsForValue().get(“key”);
if (value != null) {
cache.put(“key”, value);
}
}

## 2. Key分片方案
# 将热Key分片
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info:1 “{\”name\”:\”张三\”,\”age\”:25}”
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info:2 “{\”email\”:\”zhangsan@example.com\”,\”phone\”:\”13800138000\”}”

## 3. 读写分离方案
# 配置主从复制
# 主节点配置
bind 192.168.1.100
port 6379
dir /redis/fgdata

# 从节点配置
bind 192.168.1.101
port 6379
dir /redis/fgdata
slaveof 192.168.1.100 6379

# 应用代码中使用读写分离
// 写操作使用主节点
redisTemplate.setConnectionFactory(primaryConnectionFactory);
redisTemplate.opsForValue().set(“key”, “value”);

// 读操作使用从节点
redisTemplate.setConnectionFactory(slaveConnectionFactory);
String value = redisTemplate.opsForValue().get(“key”);

## 4. 集群扩容方案
# 添加新节点
$ /redis/app/bin/redis-cli –cluster add-node 192.168.1.102:6379 192.168.1.100:6379 -a fgedu@2026

# 重新分片
$ /redis/app/bin/redis-cli –cluster reshard 192.168.1.100:6379 -a fgedu@2026

## 5. 限流方案
# 使用Redis实现限流
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 eval “local current = redis.call(‘incr’, KEYS[1]); if current == 1 then redis.call(‘expire’, KEYS[1], ARGV[1]); end; return current;” 1 hotkey:limit 10

## 1. 检查Redis性能
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 info stats
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 –latency-history

## 2. 查找热Key
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 info commandstats
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 slowlog get

## 3. 分析热Key的访问模式
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 monitor | grep hotkey

## 4. 查看Redis内存使用情况
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 info memory

## 5. 常见故障及解决
– CPU使用率高：使用本地缓存或读写分离减轻压力
– 网络拥塞：优化网络配置，增加带宽
– 内存使用不均衡：使用Key分片或集群扩容
– 实例宕机：使用限流方案，避免突发流量

风哥提示：Redis接口限流是保护系统的重要机制，合理的限流策略可以防止系统过载，确保系统的稳定性和可用性。在实际应用中，需要根据具体业务场景和数据特点，选择合适的限流算法和策略。

Part04-生产案例与实战讲解

4.1 本地缓存方案

## 1. 场景描述
– 热点商品信息，访问频率高
– 数据更新频率低

## 2. 优化方案
– 在应用服务器上使用本地缓存
– 定期从Redis更新数据

## 3. 实战操作
# 安装Caffeine缓存库
$ mvn dependency:copy -Dartifact=com.github.ben-manes.caffeine:caffeine:3.1.1 -DoutputDirectory=lib

# 应用代码示例
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

public class LocalCacheExample {
private static final Cache cache = Caffeine.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES)
.maximumSize(1000)
.build();

public static String getProductInfo(String productId) {
String key = “product:” + productId + “:info”;
String value = cache.getIfPresent(key);
if (value == null) {
// 从Redis获取数据
value = redisGet(key);
if (value != null) {
cache.put(key, value);
}
}
return value;
}

private static String redisGet(String key) {
// 从Redis获取数据的实现
return “{\”id\”:\”2001\”,\”name\”:\”iPhone 14\”,\”price\”:\”6999\”}”;
}
}

## 4. 测试
$ java -cp “lib/*:classes” LocalCacheExample

# 输出示例
Product info: {“id”:”2001″,”name”:”iPhone 14″,”price”:”6999″}

## 1. 场景描述
– 热点用户信息，访问频率高
– 数据量大

## 2. 优化方案
– 将用户信息分散到多个Key中
– 按字段或功能分片

## 3. 实战操作
# 原热Key
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info “{\”name\”:\”张三\”,\”age\”:25,\”email\”:\”zhangsan@example.com\”,\”phone\”:\”13800138000\”,\”address\”:\”北京市朝阳区\”,\”company\”:\”ABC公司\”,\”position\”:\”工程师\”}”

# 优化后（按功能分片）
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info:basic “{\”name\”:\”张三\”,\”age\”:25}”
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info:contact “{\”email\”:\”zhangsan@example.com\”,\”phone\”:\”13800138000\”}”
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set user:1001:info:work “{\”company\”:\”ABC公司\”,\”position\”:\”工程师\”}”

## 4. 测试
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 get user:1001:info:basic
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 get user:1001:info:contact
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 get user:1001:info:work

# 输出示例
“{\”name\”:\”张三\”,\”age\”:25}”
“{\”email\”:\”zhangsan@example.com\”,\”phone\”:\”13800138000\”}”
“{\”company\”:\”ABC公司\”,\”position\”:\”工程师\”}”

## 1. 场景描述
– 热点新闻信息，读多写少
– 访问频率高

## 2. 优化方案
– 使用主从复制，将读请求分散到多个从节点
– 主节点负责写操作，从节点负责读操作

## 3. 实战操作
# 配置主节点
$ vi /redis/fgdata/redis.conf

bind 192.168.1.100
port 6379
dir /redis/fgdata
requirepass fgedu@2026

# 配置从节点1
$ vi /redis/fgdata/redis.conf

bind 192.168.1.101
port 6379
dir /redis/fgdata
slaveof 192.168.1.100 6379
masterauth fgedu@2026

# 配置从节点2
$ vi /redis/fgdata/redis.conf

bind 192.168.1.102
port 6379
dir /redis/fgdata
slaveof 192.168.1.100 6379
masterauth fgedu@2026

# 启动所有节点
$ /redis/app/bin/redis-server /redis/fgdata/redis.conf # 主节点
$ /redis/app/bin/redis-server /redis/fgdata/redis.conf # 从节点1
$ /redis/app/bin/redis-server /redis/fgdata/redis.conf # 从节点2

# 应用代码示例
// 写操作使用主节点
RedisTemplate primaryRedisTemplate = new RedisTemplate<>();
primaryRedisTemplate.setConnectionFactory(primaryConnectionFactory);
primaryRedisTemplate.opsForValue().set(“news:1001:content”, “Breaking news…”);

// 读操作使用从节点（轮询或随机选择）
RedisTemplate slaveRedisTemplate = new RedisTemplate<>();
slaveRedisTemplate.setConnectionFactory(slaveConnectionFactory);
String content = slaveRedisTemplate.opsForValue().get(“news:1001:content”);

## 4. 测试
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 6379 -a fgedu@2026 set news:1001:content “Breaking news: Redis is awesome!”
$ /redis/app/bin/redis-cli -h 192.168.1.101 -p 6379 -a fgedu@2026 get news:1001:content
$ /redis/app/bin/redis-cli -h 192.168.1.102 -p 6379 -a fgedu@2026 get news:1001:content

# 输出示例
OK
“Breaking news: Redis is awesome!”
“Breaking news: Redis is awesome!”

## 1. 场景描述
– 整体负载较高，多个Key成为热Key
– 单个节点无法承受压力

## 2. 优化方案
– 增加Redis节点数量，分散负载
– 重新分片，使Slot分布均衡

## 3. 实战操作
# 现有集群：3主3从
# 节点1：192.168.1.100:7000（主节点）
# 节点2：192.168.1.101:7000（主节点）
# 节点3：192.168.1.102:7000（主节点）
# 节点4：192.168.1.100:7001（从节点）
# 节点5：192.168.1.101:7001（从节点）
# 节点6：192.168.1.102:7001（从节点）

# 添加新主节点
$ /redis/app/bin/redis-cli –cluster add-node 192.168.1.103:7000 192.168.1.100:7000 -a fgedu@2026

# 添加新从节点
$ /redis/app/bin/redis-cli –cluster add-node 192.168.1.103:7001 192.168.1.100:7000 –cluster-slave –cluster-master-id -a fgedu@2026

# 重新分片
$ /redis/app/bin/redis-cli –cluster reshard 192.168.1.100:7000 -a fgedu@2026

# 按照提示输入：
# 1. 要移动的Slot数量：4096
# 2. 目标节点ID：输入新主节点的ID
# 3. 源节点ID：输入all
# 4. 确认：yes

## 4. 测试
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 7000 -a fgedu@2026 cluster info
$ /redis/app/bin/redis-cli -h 192.168.1.100 -p 7000 -a fgedu@2026 cluster nodes

# 输出示例
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:8
cluster_size:4
cluster_current_epoch:8
cluster_my_epoch:1
cluster_stats_messages_ping_sent:1234
cluster_stats_messages_pong_sent:1234
cluster_stats_messages_sent:2468
cluster_stats_messages_ping_received:1234
cluster_stats_messages_pong_received:1234
cluster_stats_messages_meet_received:7
cluster_stats_messages_received:2468

更多学习教程公众号风哥教程itpux_com

Part05-风哥经验总结与分享

5.1 最佳实践

Redis热Key解决方案实战最佳实践：

• 预防为主：从业务设计层面避免热Key的产生，学习交流加群风哥微信: itpux-com
• 多种方案结合：根据具体业务场景选择合适的解决方案，必要时结合多种方案
• 监控预警：建立完善的热Key监控和预警机制，及时发现和处理热Key
• 缓存预热：提前将热点数据加载到缓存中，避免突发流量导致的热Key
• 合理分片：将热点数据分片存储，分散访问压力
• 本地缓存：使用本地缓存减轻Redis的压力，适合读多写少的场景
• 读写分离：使用主从复制，将读请求分散到多个从节点
• 集群扩容：根据负载情况，适时增加Redis节点数量

5.2 常见问题