RedisTemplate 序列化用错,线上多了 3 个 G 的隐形 key

警报

周三下午收到一条 Redis 内存告警:集群内存使用率从 45% 涨到了 82%。

我们的 Redis 集群是给十几个服务共用的,平时内存 2.3G 左右,波动不大。那天下午涨到了 5.1G。涨了将近 3 个 G,而且还在涨。

第一反应是有人写了个没设 TTL 的大 key。这种事在共用的 Redis 上太常见了。

定位:一堆看不懂的 key

先看总量:

bash 复制代码
redis-cli -h xxx -p 6379 --bigkeys

--bigkeys 只告诉我们最大的那个 value 有多大,但我们要找的是大量小的、不断增长的 key。

换用 --memkeys:

bash 复制代码
redis-cli -h xxx -p 6379 --memkeys

也没有明显异常。

那就只能数。按前缀统计:

bash 复制代码
redis-cli -h xxx -p 6379 --scan --count 1000 | head -100000 | awk -F: '{print $1}' | sort | uniq -c | sort -rn | head -20

跑出来的结果里有一行很扎眼:

复制代码
  412873  \xac\xed\x00\x05t\x00\x0forder:cache

四十多万个 key,前缀是一堆乱码。

再实际捞一个出来看:

bash 复制代码
redis-cli -h xxx -p 6379 --scan --pattern '*order:cache*' --count 5
arduino 复制代码
"\xac\xed\x00\x05t\x00\x12order:cache:202610..."
"\xac\xed\x00\x05t\x00\x12order:cache:202610..."

看到 \xac\xed\x00\x05 这个前缀,我心里就有数了。

这是 Java 原生序列化的魔术头。

0xACED 是 Java ObjectOutputStream 的流魔数(STREAM_MAGIC),0x0005 是版本号。后面那个 t 是 TC_STRING 标记,再往后是字符串长度和内容。

根因:RedisTemplate vs StringRedisTemplate

Spring Data Redis 提供了两个模板:

  • StringRedisTemplate:key 和 value 都用 StringRedisSerializer,存进去什么样,Redis 里就是什么样。
  • RedisTemplate:默认用 JdkSerializationRedisSerializer,key 和 value 都会被 Java 序列化成二进制。

我们有个服务,代码里写的是:

java 复制代码
@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void cacheOrder(String orderNo, OrderVO order) {
    redisTemplate.opsForValue().set("order:cache:" + orderNo, order, 30, TimeUnit.MINUTES);
}

作者的想法大概是"我要存对象,所以用 RedisTemplate"。这没错,但他没有配置 key 的序列化器。

RedisTemplate 默认的 key 序列化器是 JdkSerializationRedisSerializer,所以 key "order:cache:xxx" 被序列化成了 \xac\xed\x00\x05t\x00\x12order:cache:xxx。

这一串二进制在 Redis 里是 26 个字节,而原字符串只有 18 字节。四十多万个 key,光 key 本身的内存开销就白白多出来了。

更要命的是------这个 key 你没法用普通的方式删。

bash 复制代码
redis-cli DEL "order:cache:20261012001"

删不掉。因为 Redis 里真实的 key 是那串二进制。你在客户端输的字符串,跟它不匹配。

这就是那 3 个 G 的来源。而且因为这个 key 是被 Java 序列化的,每次业务代码去找它,都是拿 "order:cache:xxx" 去匹配那个二进制 key(通过同样的序列化器),所以业务上竟然一切正常。程序跑得好好的,只有内存悄悄涨。

顺便发现:同一个 key 存了两份

清理的时候我又发现一个更隐蔽的问题。

我用 SCAN 找 order:cache 的时候,发现有两批 key:

less 复制代码
\xac\xed\x00\x05t\x00\x12order:cache:20261012001   <- 服务A写的(JdkSerialization)
order:cache:20261012001                            <- 服务B写的(String)

同一个业务 key,两个服务各存了一份。

服务 A 用了 RedisTemplate(默认序列化),服务 B 用了 StringRedisTemplate。两边读的时候都读自己的那份,所以各自都正常。但数据是双份的,内存也是双份的。

而且如果哪天 A 读到了 B 写的(比如运维手动用 redis-cli 修了个值),就会直接抛 SerializationException,因为它们解读字节的方式不同。

修复

修复分三步。

第一步:统一序列化配置。

我们定了个规范:

  • key 一律用 StringRedisSerializer(这是铁律,key 必须是可读的字符串)
  • value:简单字符串用 StringRedisSerializer,对象用 GenericJackson2JsonRedisSerializer

统一配一个模板:

java 复制代码
@Configuration
public class RedisConfig {

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

        StringRedisSerializer keySerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer valueSerializer =
                new GenericJackson2JsonRedisSerializer();

        template.setKeySerializer(keySerializer);
        template.setHashKeySerializer(keySerializer);
        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

注意 GenericJackson2JsonRedisSerializer 会在 JSON 里额外写入 @class 字段来记录类型,这样反序列化时能还原成原来的类。代价是存储稍微大一点,但换来的是可读性和可维护性。

如果你不想要 @class,可以用 Jackson2JsonRedisSerializer<Object> 配合自定义的 ObjectMapper,但那样就只能反序列化成 Map 了。取舍看场景。

第二步:清历史脏数据。

这个要小心,不能用 KEYS,几十万个 key 会把 Redis 阻塞住。

用 SCAN:

bash 复制代码
#!/bin/bash
# 分批删除 Java 序列化格式的脏 key
redis-cli -h $HOST -p $PORT --scan --pattern '*order:cache*' --count 500 | \
while read -r key; do
    # 只删带 Java 序列化魔数的(用前缀匹配不现实,这里按长度和不可见字符判断)
    echo "DEL '$key'"
done | redis-cli -h $HOST -p $PORT --pipe

实际执行的时候我是先用 Lua 脚本试删了一小批,确认没误伤业务 key(因为业务已经不用这个格式了),再全量删。

这里有个经验:删 Redis 数据之前,一定要先确认"这个 key 现在还有人读吗"。 我的办法是先删 100 个,观察半小时业务日志有没有异常,再删 1000 个,再观察。慢慢来。

第三步:加监控。

事后我在 Redis 层面加了个告警:如果一分钟内出现大量以 \xac\xed 开头的 key,直接告警。写了个小脚本跑在巡检任务里:

bash 复制代码
redis-cli --scan --pattern '*' --count 1000 | \
  grep -c $'\xac\xed' || true

这个脚本一直留着,后来又抓到过一次------另一个服务的新同学又踩了同一个坑。

第二个坑:Redisson 的 INCRBY

序列化这件事解决之后,我在同一个项目里又踩了一个相关的坑。

我们有个接口限流计数器,用的是 Redisson:

java 复制代码
// 第一版:用 RBucket 存数字,然后 getAndSet
RBucket<Long> bucket = redissonClient.getBucket("limit:api:" + api);
Long current = bucket.get();
if (current == null) {
    bucket.set(1L, 1, TimeUnit.MINUTES);
    return true;
}
if (current >= maxQps) {
    return false;
}
bucket.set(current + 1, 1, TimeUnit.MINUTES);

这段代码有并发问题------读和写不是原子的。两个请求同时读到 current=5,都写成 6,就少计了一次。

改成原子操作:

java 复制代码
RAtomicLong counter = redissonClient.getAtomicLong("limit:api:" + api);
long current = counter.incrementAndGet();

看起来很合理,但上线之后报错:

sql 复制代码
org.redisson.client.RedisException:
ERR value is not an integer or out of range

查了一下原因:RBucket 和 RAtomicLong 用的编码器不一样。

  • RAtomicLong 内部用 LongCodec,存的是纯数字字符串(比如 "6"),能被 Redis 的 INCR 直接处理。
  • RBucket 用默认编码器(我们配的是 JsonJacksonCodec),存的是带元信息的序列化字节。

所以我先用 RBucket 存了 1,再用 RAtomicLong 去 incrementAndGet,Redis 拿到的那串字节不是数字,INCR 直接报错。反过来也一样。

教训:同一个 key,从始至终只能用同一种数据类型和编码器去操作。 别一会儿 RBucket 一会儿 RAtomicLong,它们眼里的"值"根本不是同一回事。

修法有两种,我选了第一种:

java 复制代码
// 方案一:全程用 RAtomicLong,并且显式指定 LongCodec(默认就是,这里只是写出来强调)
RAtomicLong counter = redissonClient.getAtomicLong(key);

// 方案二:如果一定要用 RBucket,就显式指定编码器
RBucket<String> bucket = redissonClient.getBucket(key, StringCodec.INSTANCE);

顺带说一个更隐蔽的情况:如果某个 key 被 RedisTemplate 写过(比如被一个临时脚本写了个 "0"),Redisson 的 RAtomicLong 也是能用的 ,因为 "0" 本身就是合法整数。但如果 RedisTemplate 配的是 JSON 序列化,写进去的是 "\"0\""(带引号),那就又不匹配了。

这种跨客户端、跨序列化方案的混用,是 Redis 使用中最容易出事故的地方。

Redis 消息队列:我踩过的另一个小坑

顺便提一下,我们后来还用 Redis Stream 做过轻量级的消息队列(因为不想为了一个小功能引入 MQ)。

Stream 的 XADD / XREADGROUP / XACK 用起来挺顺手,但有两点要注意:

1. 消息不会自动删除。 XADD 加进去的消息会一直保留,要配 MAXLEN 截断:

java 复制代码
// Redisson 里
RStream<String, String> stream = redissonClient.getStream("order:stream");
stream.add(StreamAddArgs.entry("id", orderId), StreamMessageId.AUTO_GENERATED, 1000, true);
// 上面这个 1000 就是 MAXLEN

或者用 Redis 的 XADD key MAXLEN ~ 1000 * field value,~ 表示近似截断,性能更好。

2. Pending 列表会累积。 如果消费方一直不 XACK,pending 列表会越来越大。得有一个定时任务去 XPENDING 检查并处理死信。

我们用 Redisson 的 RStream 时,XACK 是通过 stream.ack(group, msgId) 做的。注意 group 要先创建:

java 复制代码
stream.createGroup(StreamMessageId.NEWEST, "myGroup");

这个 StreamMessageId.NEWEST 表示从最新消息开始消费。如果你想要从头消费,用 StreamMessageId.ALL。我第一次用的时候选了 NEWEST,结果测试时发的消息一条都收不到,白白查了半天。

最后

Redis 的使用坑,我总结下来就一句话:

别让同一个 key,在不同的地方有不同的"解释方式"。

序列化方式、编码器、数据类型------任何一个维度上不统一,都会产生"程序跑得好好的但内存/数据坏了"这种最难查的问题。

具体到实践:

  1. key 一律用 StringRedisSerializer,别让 key 变成二进制。key 是给人看的。
  2. 一个项目里只保留一套 Redis 配置 ,别让不同的模块各自 new RedisTemplate()。
  3. 同一个 key 只用一种客户端、一种编码器操作。 用 Redisson 就全用 Redisson。
  4. 加一个巡检脚本,盯着有没有新的二进制 key 出现。

第 4 条最土,但最有用。我加了这个巡检之后,又抓到了两次同类问题------如果不加,它们大概会像那 3 个 G 一样,悄悄涨到把集群撑爆。


相关推荐
掘金者阿豪12 分钟前
MySQL兼容性实践:从SQL语法适配到业务系统平滑迁移
后端
超低空1 小时前
一文说清LRU算法
后端·算法·架构
前端小万1 小时前
思考,行动,复盘|2026
前端·后端·面试
Sailing1 小时前
🚀客户端都超时了,你的 Go 服务还在查库?Context 取消链路不打通,连接池迟早被打爆
后端·面试·go
拖孩2 小时前
# 我又用 AI 做了个小程序:24 天,记录我这辈子认识的人
前端·后端·微信小程序
Csvn2 小时前
Nginx rewrite 与 server_name:last/break 语义、多域名匹配与伪静态
后端·nginx
AAA修煤气灶刘哥2 小时前
32 GB 内存跑起 1800 亿参数模型,代价是什么?
人工智能·后端·架构
SimonKing3 小时前
零 OCR 依赖!Firecrawl 这个 Rust 库把 Word / PPT / Excel 全变成 Markdown
java·后端·程序员
Rain的Java大神之路3 小时前
别被 ChatGPT 的打字机效果骗了:一字一字蹦,才是 LLM 自回归的命门(附大厂 Java 流式落地)
java·后端·面试