# 掃描耗時(shí)型操作，建議在從節(jié)點(diǎn)執(zhí)行
redis-cli -h 127.0.0.1 -p 6379 --bigkeys -i 0.1

# 輸出示例
[00.00%] Biggest string found 'user:1024:info' has 12 bytes
[12.34%] Biggest hash   found 'product:8888:spec' has 10086 fields

// 計(jì)算Key內(nèi)存占用
Long memUsage = redisTemplate.execute(
    (RedisCallback<Long>) connection -> 
        connection.serverCommands().memoryUsage("user:1024:info".getBytes())
);

public List<Map.Entry<String, Long>> findBigKeys(int threshold) {
    List<Map.Entry<String, Long>> bigKeys = new ArrayList<>();
    Cursor<byte[]> cursor = redisTemplate.execute(
        (RedisCallback<Cursor<byte[]>>) connection -> 
            connection.scan(ScanOptions.scanOptions().count(100).build())
    );

    while (cursor.hasNext()) {
        byte[] keyBytes = cursor.next();
        String key = new String(keyBytes);
        DataType type = redisTemplate.type(key);
        
        long size = 0;
        switch (type) {
            case STRING:
                size = redisTemplate.opsForValue().size(key);
                break;
            case HASH:
                size = redisTemplate.opsForHash().size(key);
                break;
            // 其他類型處理...
        }
        
        if (size > threshold) {
            bigKeys.add(new AbstractMap.SimpleEntry<>(key, size));
        }
    }
    return bigKeys;
}

# 使用rdb-tools分析
rdb -c memory dump.rdb --bytes 10240 > bigkeys.csv

# 輸出示例
database,type,key,size_in_bytes,encoding,num_elements,len_largest_element
0,hash,user:1024:tags,1048576,hashtable,50000,128

# redis_exporter配置
- name: redis_key_size
  rules:
  - record: redis:key_size:bytes
    expr: redis_key_size{job="redis"}
    labels:
      severity: warning

public void splitBigHash(String originalKey, int batchSize) {
    Map<Object, Object> entries = redisTemplate.opsForHash().entries(originalKey);
    List<List<Map.Entry<Object, Object>>> batches = Lists.partition(
        new ArrayList<>(entries.entrySet()), 
        batchSize
    );
    
    for (int i = 0; i < batches.size(); i++) {
        String shardKey = originalKey + ":shard_" + i;
        redisTemplate.opsForHash().putAll(shardKey, 
            batches.get(i).stream()
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
        );
    }
    redisTemplate.delete(originalKey);
}

public List<Object> getPaginatedList(String listKey, int page, int size) {
    long start = (page - 1) * size;
    long end = page * size - 1;
    return redisTemplate.opsForList().range(listKey, start, end);
}

public void safeDeleteBigKey(String key) {
    DataType type = redisTemplate.type(key);
    
    switch (type) {
        case HASH:
            redisTemplate.execute(
                "HSCAN", key, "0", "COUNT", "100", 
                (result) -> {
                    // 分批刪除字段
                    return null;
                });
            break;
        case LIST:
            while (redisTemplate.opsForList().size(key) > 0) {
                redisTemplate.opsForList().trim(key, 0, -101);
            }
            break;
        // 其他類型處理...
    }
    redisTemplate.unlink(key);
}

-- 分批次刪除Hash字段
local cursor = 0
repeat
    local result = redis.call('HSCAN', KEYS[1], cursor, 'COUNT', 100)
    cursor = tonumber(result[1])
    for _, field in ipairs(result[2]) do
        redis.call('HDEL', KEYS[1], field)
    end
until cursor == 0

public void migrateBigKey(String sourceKey, String targetKey) {
    RedisClusterConnection clusterConn = redisTemplate.getConnectionFactory()
        .getClusterConnection();
    
    int slot = ClusterSlotHashUtil.calculateSlot(sourceKey);
    RedisNode node = clusterConn.clusterGetNodeForSlot(slot);
    
    try (Jedis jedis = new Jedis(node.getHost(), node.getPort())) {
        // 分批遷移數(shù)據(jù)
        ScanParams params = new ScanParams().count(100);
        String cursor = "0";
        do {
            ScanResult<Map.Entry<String, String>> scanResult = 
                jedis.hscan(sourceKey, cursor, params);
            List<Map.Entry<String, String>> entries = scanResult.getResult();
            
            // 分批寫入新Key
            Map<String, String> batch = entries.stream()
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            jedis.hmset(targetKey, batch);
            
            cursor = scanResult.getCursor();
        } while (!"0".equals(cursor));
    }
}

JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(200);         // 最大連接數(shù)
config.setMaxWaitMillis(1000);   // 最大等待時(shí)間
config.setTestOnBorrow(true);    // 獲取連接時(shí)驗(yàn)證

ClientOptions options = ClientOptions.builder()
    .autoReconnect(true)
    .publishOnScheduler(true)
    .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(1)))
    .build();

@CircuitBreaker(name = "redisService", fallbackMethod = "fallback")
public Object getData(String key) {
    return redisTemplate.opsForValue().get(key);
}

private Object fallback(String key, Throwable t) {
    return loadFromBackup(key);
}