# 通过环境变量传递密码，避免明文暴露
export REDISCLI_AUTH='<密码>'

# 排查大 Key：按数据类型分别输出元素个数最多的 Key
redis-cli -h <实例地址> -p <端口> --bigkeys

# 排查热 Key：基于 LFU 访问频次统计输出高频 Key
redis-cli -h <实例地址> -p <端口> --hotkeys

import redis.clients.jedis.Jedis;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class HotKeyDetector {

    // Key → 访问次数
    private static final ConcurrentHashMap<String, AtomicLong> KEY_COUNT = new ConcurrentHashMap<>();
    // Key → 累计耗时（纳秒）
    private static final ConcurrentHashMap<String, AtomicLong> KEY_TIME = new ConcurrentHashMap<>();

    /**
     * 包装 Jedis get 操作，自动统计每个 Key 的访问次数与耗时。
     */
    public static String get(Jedis jedis, String key) {
        long start = System.nanoTime();
        try {
            return jedis.get(key);
        } finally {
            record(key, System.nanoTime() - start);
        }
    }

    private static void record(String key, long nanos) {
        KEY_COUNT.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet();
        KEY_TIME.computeIfAbsent(key, k -> new AtomicLong()).addAndGet(nanos);
    }

    /**
     * 打印 TopN 热 Key，建议通过定时任务（如每 60 秒）调用。
     */
    public static void printTopN(int n) {
        System.out.println("===== Top " + n + " Hot Keys =====");
        KEY_COUNT.entrySet().stream()
            .sorted((a, b) -> Long.compare(b.getValue().get(), a.getValue().get()))
            .limit(n)
            .forEach(e -> {
                String key = e.getKey();
                long count = e.getValue().get();
                long totalNs = KEY_TIME.getOrDefault(key, new AtomicLong()).get();
                double avgMs = count > 0 ? (totalNs / 1_000_000.0) / count : 0;
                System.out.printf("Key: %s | Count: %d | Avg: %.2f ms%n",
                    key, count, avgMs);
            });
    }

    /**
     * 重置统计（每次打印后调用，避免数据累积）。
     */
    public static void reset() {
        KEY_COUNT.clear();
        KEY_TIME.clear();
    }
}

# Hash：HSCAN + HDEL 渐进式删除过期成员，循环执行直至清理完成
HSCAN key cursor COUNT 100
HDEL key field1 field2 ...

# List：LTRIM 分批裁剪，仅保留前 1,000 条
LTRIM key 0 999

# Redis 4.0+：UNLINK 异步删除整个大 Key，避免阻塞
UNLINK large_key

// 写入：压缩后以二进制形式存入
// gzipCompress / gzipDecompress 可基于 java.util.zip.GZIPOutputStream 自行实现
byte[] compressed = gzipCompress(rawJsonString);
jedis.set(key.getBytes(), compressed);

// 读取：取出二进制数据后解压还原
byte[] data = jedis.get(key.getBytes());
String rawJson = gzipDecompress(data);

# 拆分前
user:profile:1001 → 2MB JSON

# 拆分后（按字段分组）
user:profile:1001:basic    → 基础信息
user:profile:1001:extend   → 扩展信息
user:profile:1001:settings → 设置信息

# Hash 拆分：对 Field 做哈希取模，分散到 N 个子 Hash
# 分片编号 = hash(field) % N，写入与读取使用同一规则定位
user:cart:1001:shard_0   → 存放取模结果为 0 的 Field
user:cart:1001:shard_1   → 存放取模结果为 1 的 Field
...

# 转存前
file:report:2025-q4 → 15MB PDF BLOB

# 转存后
file:report:2025-q4:url → "https://bucket.cos.region.myqcloud.com/report-2025-q4.pdf"
file:report:2025-q4:meta → {"size": 15728640, "md5": "abc123..."}

// Caffeine 本地缓存热点数据
private static final LoadingCache<String, String> HOT_KEY_CACHE = Caffeine.newBuilder()
    .maximumSize(1000)                            // 最大缓存条目数
    .expireAfterWrite(50, TimeUnit.MILLISECONDS)  // 过期时间，控制数据不一致窗口
    .build(key -> {
        // 缓存未命中时回源 Redis，从连接池获取连接
        try (Jedis jedis = JEDIS_POOL.getResource()) {
            return jedis.get(key);
        }
    });

# 原始热 Key
hot:product:1001

# 打散为多副本
hot:product:1001:0 → 副本 0
hot:product:1001:1 → 副本 1
hot:product:1001:2 → 副本 2

// 读取时随机选择一个副本，将请求分散到不同分片
int index = ThreadLocalRandom.current().nextInt(REPLICA_COUNT);
String key = "hot:product:" + productId + ":" + index;
try (Jedis jedis = JEDIS_POOL.getResource()) {
    String value = jedis.get(key);
}

用户请求 → Nginx 本地缓存 → 应用本地缓存(Caffeine) → Redis → 数据库