第一章：Redis RESP协议解析的Go语言实践概览
Redis 的通信基石是其自定义的序列化协议 RESP（REdis Serialization Protocol），它以简洁、可读、易解析著称，支持简单字符串、错误、整数、批量字符串和数组五种基本类型。在 Go 语言生态中，深入理解 RESP 不仅有助于开发高性能客户端，还能支撑自研代理、协议转换网关或调试工具等场景。
RESP 核心类型与线格式样例
- 简单字符串：以
+开头，如+OK\r\n - 错误：以
-开头，如-ERR unknown command 'foo'\r\n - 整数：以
:开头，如:1000\r\n - 批量字符串：以
$开头后跟字节长度，如$5\r\nhello\r\n - 数组：以
*开头后跟元素个数，如*2\r\n$3\r\nSET\r\n$5\r\nmykey\r\n
使用 Go 实现基础 RESP 解析器
以下代码片段展示了如何用 bufio.Scanner 逐行读取并识别 RESP 类型前缀：
func parseRESPLine(line string) (string, interface{}, error) {
if len(line) == 0 {
return "", nil, errors.New("empty line")
}
switch line[0] {
case '+':
return "simple-string", strings.TrimSpace(line[1:]), nil
case '-':
return "error", strings.TrimSpace(line[1:]), nil
case ':':
if i, err := strconv.ParseInt(line[1:], 10, 64); err == nil {
return "integer", i, nil
}
return "integer", nil, errors.New("invalid integer format")
case '$':
// 后续需读取指定长度的批量字符串（此处省略多行逻辑）
return "bulk-string", nil, nil
case '*':
count, _ := strconv.Atoi(line[1:])
return "array", count, nil
default:
return "unknown", nil, fmt.Errorf("unrecognized prefix: %q", line[0])
}
}该函数返回类型标识、解析值及错误，为构建完整 RESP 解析器提供原子能力。实际项目中建议结合 io.Reader 流式处理，避免内存拷贝，并注意处理 \r\n 换行符的跨平台兼容性。
典型调试验证方式
启动本地 Redis 服务后，可通过 nc 手动发送 RESP 命令验证解析逻辑：
echo -ne "*2\r\n$3\r\nGET\r\n$3\r\nfoo\r\n" | nc localhost 6379观察返回是否为 $-1\r\n（nil）或 $5\r\nhello\r\n，再比对 Go 解析器输出是否一致。此闭环验证是协议实践的关键环节。
第二章：Bulk String空字节陷阱的深度解析与防御实现
2.1 RESP Bulk String格式规范与空字节（\x00）语义歧义分析
RESP Bulk String 以 $<len>\r\n<data>\r\n 编码，其中 <len> 为字节长度（非字符数），<data> 可含任意二进制内容——包括 \x00。
空字节的合法地位
- Redis 协议明确允许
\x00出现在 bulk string 的<data>段； - 客户端/服务端不得因
\x00提前截断或报错； - C 语言实现中需严格按
<len>字节数读取，禁用strlen()类函数。
典型歧义场景
// ❌ 危险：错误假设 data 为 C 字符串
char *data = malloc(len + 1);
read(fd, data, len); // 未初始化末尾 \0
data[len] = '\0'; // 强制补零 → 掩盖真实 \x00 位置
printf("%s", data); // 遇首个 \x00 截断，丢失后续数据逻辑分析：
len=5,data=[a,\x00,b,c,\x00]时，printf仅输出"a"，破坏协议完整性。必须通过显式len边界访问，禁止隐式字符串语义。
| 场景 | 是否符合 RESP | 原因 |
|---|---|---|
$3\r\nabc\r\n |
✅ | 标准 ASCII |
$4\r\nab\x00c\r\n |
✅ | \x00 在 data 中合法 |
$3\r\nab\x00\r\n |
✅ | 长度声明与实际字节数一致 |
graph TD
A[收到 $5\r\na\x00b\x00c\r\n] --> B{按 len=5 读取}
B --> C[得到字节数组 [a,0x00,b,0x00,c]]
C --> D[原样存储/转发，不解析 \x00]2.2 Go语言net.Conn读取中\x00截断导致的协议解析失败复现
现象复现：Read() 遇 \x00 提前终止？
Go 的 net.Conn.Read([]byte) 不会因 \x00 终止，但若上层协议（如自定义二进制帧）将 \x00 误判为字符串终结符（如 C 风格 strlen），则解析逻辑会提前截断。
关键误区：混淆字节流与字符串语义
Read()返回的是原始字节，\x00仅是0x00byte，无特殊语义- 错误示例：用
strings.Split(string(buf), "\x00")解析二进制协议 →\x00后数据丢失
// ❌ 危险：强制转 string 导致 \x00 截断
data := make([]byte, 1024)
n, _ := conn.Read(data)
parts := strings.Split(string(data[:n]), "\x00") // ⚠️ \x00 后所有字节被丢弃逻辑分析：
string(data[:n])将整个切片转为 UTF-8 字符串，但 Go 字符串内部不禁止\x00；问题出在strings.Split—— 它按 rune 切分，而\x00是合法 rune，真正风险在于后续用 C-style 函数（如C.strlen）处理该字符串时被截断。生产环境常见于 CGO 调用或序列化库误用。
正确做法对比
| 场景 | 错误方式 | 推荐方式 |
|---|---|---|
| 分割帧 | strings.Split(string(b), "\x00") |
bytes.Split(b, []byte{0}) |
| 查找边界 | strings.Index(string(b), "\x00") |
bytes.IndexByte(b, 0) |
| 构建协议 | fmt.Sprintf("%s\x00%s", a, b) |
append(append([]byte(a), 0), b...) |
// ✅ 安全：全程操作 []byte，零拷贝且语义明确
frame, _ := readFrame(conn) // 自定义读取完整帧逻辑
parts := bytes.Split(frame, []byte{0}) // 精确按字节 0x00 分割参数说明：
bytes.Split(frame, []byte{0})中[]byte{0}明确指定单字节分隔符，避免任何字符串编码歧义；readFrame()应基于长度前缀或结束标记实现，而非依赖\x00作为唯一帧界。
根本规避路径
graph TD
A[net.Conn.Read] --> B[原始字节流]
B --> C{协议设计}
C -->|含\x00数据| D[使用长度前缀或CRC校验]
C -->|需分隔符| E[选用非数据字符如 0xFF 或双字节标记]
D --> F[安全解析]
E --> F2.3 基于bytes.Reader的零拷贝空字节安全解析器设计
传统解析器在处理含 \x00 的二进制协议（如 Protobuf、自定义帧格式）时，常因 strings.NewReader 或 bufio.Scanner 遇空字节提前截断而失效。bytes.Reader 天然支持任意字节序列，且底层直接暴露 []byte 切片，为零拷贝解析提供基础。
核心优势对比
| 特性 | strings.Reader |
bytes.Reader |
bufio.Reader |
|---|---|---|---|
| 空字节支持 | ❌（UTF-8 解码失败） | ✅（纯字节视图） | ✅（但需额外缓冲） |
| 零拷贝读取 | ❌（转 string 强制拷贝） | ✅（Read(p) 直接写入用户切片） |
⚠️（内部缓冲导致隐式拷贝） |
安全解析器实现
func NewNullSafeParser(data []byte) *NullSafeParser {
return &NullSafeParser{r: bytes.NewReader(data)}
}
type NullSafeParser struct {
r *bytes.Reader
}
func (p *NullSafeParser) ReadUint32() (uint32, error) {
var buf [4]byte
_, err := io.ReadFull(p.r, buf[:]) // 零拷贝：直接填充用户栈数组
if err != nil {
return 0, err
}
return binary.BigEndian.Uint32(buf[:]), nil // 无内存分配，无空字节敏感逻辑
}io.ReadFull(p.r, buf[:]) 确保读满 4 字节，bytes.Reader 的 Read 方法不检查内容语义，完全绕过空字节陷阱；buf 位于栈上，避免堆分配，binary.BigEndian.Uint32 接收 []byte 视图，全程无数据复制。
graph TD A[原始字节流] –> B[bytes.Reader] B –> C{ReadFull into stack buffer} C –> D[binary decode] D –> E[业务字段]
2.4 测试用例驱动：覆盖含\x00的key、value、error message全场景验证
零字节边界挑战
\x00 在 C 风格字符串中表示终止符，但现代存储协议（如 Redis 协议、Protobuf 序列化）需显式支持二进制安全。忽略该字符将导致截断、解析崩溃或信息泄露。
全场景验证矩阵
| 场景类型 | 示例值 | 预期行为 |
|---|---|---|
key 含 \x00 |
"user\x00id:123" |
成功存取，长度精确校验 |
value 含 \x00 |
"hello\x00world" |
完整往返，不被截断 |
error message 含 \x00 |
"auth\x00failed" |
日志可打印，不触发 panic |
核心测试片段
def test_null_in_key_value():
# 构造含 \x00 的原始字节键与值
key = b"user\x00id" # 注意：必须为 bytes，非 str
value = b"token\x00sig"
client.set(key, value) # 底层调用需跳过 C 字符串 strlen
assert client.get(key) == value # 验证二进制等价性▶ 逻辑分析：b"user\x00id" 强制以字节序列传递，绕过 Python 字符串隐式编码；client.set() 必须使用 write_raw() 接口而非 sprintf 类函数，确保长度由 len(key) 显式控制，而非 strlen() 截断。
graph TD
A[生成含\x00测试数据] --> B[序列化层校验长度]
B --> C[网络传输保留原始字节]
C --> D[服务端内存拷贝不依赖\0]
D --> E[响应error message原样回传]2.5 生产级修复方案：自定义io.Reader封装与边界缓冲区管理
核心设计目标
- 避免流式解析中跨块边界的数据截断（如 JSON 对象、Protobuf 消息）
- 支持可配置的预读缓冲区（
boundaryBuffer），最小化内存拷贝
自定义 Reader 实现
type BoundaryReader struct {
r io.Reader
buf []byte // 边界缓冲区（复用）
bufCap int
overflow []byte // 跨块残留数据
}
func (br *BoundaryReader) Read(p []byte) (n int, err error) {
if len(br.overflow) > 0 {
n = copy(p, br.overflow)
br.overflow = br.overflow[n:]
return n, nil
}
return br.r.Read(p)
}
bufCap控制最大预读长度（默认 4KB），overflow存储未完整解析的消息尾部，避免丢弃半帧数据；Read优先消费残留，保障语义完整性。
缓冲区策略对比
| 策略 | 内存开销 | 边界处理延迟 | 适用场景 |
|---|---|---|---|
| 无缓冲直读 | 极低 | 高（易截断） | 日志行尾明确 |
| 固定大小环形缓冲 | 中 | 中 | 协议头长固定 |
| 动态边界缓冲区 | 可控 | 低 | 生产级推荐 |
数据同步机制
graph TD
A[原始Reader] --> B[BoundaryReader]
B --> C{是否检测到消息边界？}
C -->|否| D[追加至buf，继续Read]
C -->|是| E[切分完整消息+残留overflow]
E --> F[交付上层业务]第三章：Inline Command编码歧义问题的识别与消解
3.1 Inline Command（如SET foo bar）在RESP2/RESP3混合环境中的协议推断漏洞
当客户端以 inline 格式发送 *3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n，而服务端同时支持 RESP2 与 RESP3 时，部分兼容层会错误地将首个 $3 解析为 RESP3 的“attribute blob”前缀，而非 RESP2 的 bulk string 长度。
协议歧义点
- RESP2：
$3→ bulk string 长度为 3 - RESP3：
$3→ 可能被误判为 attribute marker（若上下文含|或!前导）
典型触发流程
graph TD
A[Client sends inline] --> B{Server parser state}
B -->|No prior RESP3 handshake| C[Assume RESP2 → correct]
B -->|Seen RESP3 CAPA| D[Attempt RESP3 inference → misparse $3 as attr]
D --> E[Command drops or corrupts key]漏洞复现片段
# 触发命令（无换行，纯 inline）
*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n此序列在未显式协商协议版本的混合部署中，会被某些代理（如早期 redis-proxy v1.2.4）误识别为 RESP3 attribute frame，导致
$3\r\nfoo被跳过或解释为元数据，最终foo键写入失败。
| 组件 | RESP2 行为 | RESP3 推断行为 |
|---|---|---|
$3\r\nSET |
字符串长度=3 | 被当作 attribute tag |
$3\r\nfoo |
key = “foo” | 被丢弃或解析异常 |
3.2 Go解析器中命令行首部识别逻辑缺陷与状态机误判实测
Go标准库flag包在解析-flag=value形式时，对首部空格与换行符的预处理存在状态机跳转盲区。
问题复现路径
- 输入
"\n-flag=1"被错误识别为非flag token - 状态机在
scanSkipSpace阶段未重置inQuote标志位，导致后续scanWord误判起始位置
核心代码片段
// src/flag/flag.go: scanWord()
for i < len(s) && (isLetter(s[i]) || s[i] == '_' || s[i] == '-' || s[i] == '.') {
i++
}
// ❌ 缺失对s[0]是否为'\n'或'\r'的前置校验，直接进入循环该逻辑跳过空白后未验证首个有效字节是否满足flag命名规范（如不能以数字开头），造成-0abc被接受为合法flag名。
误判对比表
| 输入字符串 | 期望行为 | 实际行为 | 根本原因 |
|---|---|---|---|
"\n-flag=1" |
视为flag | 忽略并跳过 | scanSkipSpace未更新start索引 |
"-flag=1 " |
正常解析 | 正常解析 | 尾部空格被trimSpace安全处理 |
graph TD
A[读取输入] --> B{首字节∈\n\r\t?}
B -->|是| C[调用skipSpace]
B -->|否| D[进入scanWord]
C --> E[未更新start指针]
E --> F[scanWord从原pos开始→越界匹配]3.3 基于前缀长度+空白符位置双重校验的Inline Command安全判定策略
传统单点校验（如仅检查 ! 前缀）易被绕过。本策略引入前缀长度约束与首空白符偏移量验证协同判定，提升内联命令识别鲁棒性。
核心判定逻辑
- 命令必须以严格长度为2的控制前缀（如
!!）开头 - 首个空白符（空格/Tab）必须出现在索引 ≥4 的位置（即前缀+至少2字符后）
安全校验代码示例
def is_safe_inline(cmd: str) -> bool:
if len(cmd) < 6: return False # 最小长度：前缀(2)+指令(2)+空格(1)+参数(1)
if not cmd.startswith("!!"): return False # 强制双叹号前缀
first_ws = next((i for i, c in enumerate(cmd) if c.isspace()), -1)
return first_ws >= 4 and first_ws < len(cmd) - 1 # 空白符须在合法区间逻辑说明：
first_ws >= 4确保指令主体至少含2字符（防!! a类短命注入），< len(cmd)-1排除末尾空白导致的截断风险。
校验效果对比
| 输入样例 | 前缀长度 | 首空白位置 | 判定结果 |
|---|---|---|---|
!!ls -l |
2 | 4 | ✅ 安全 |
!! rm -rf / |
2 | 3 | ❌ 拒绝（过早空白） |
!ls -l |
1 | — | ❌ 前缀不足 |
graph TD
A[输入字符串] --> B{长度≥6？}
B -->|否| C[拒绝]
B -->|是| D{是否以!!开头？}
D -->|否| C
D -->|是| E[定位首个空白符]
E --> F{位置≥4且非末尾？}
F -->|否| C
F -->|是| G[接受为合法Inline Command]第四章：RESP3类型自动降级引发的兼容性危机与应对
4.1 RESP3新增类型（map、set、double、bool）在客户端未声明能力时的服务器降级行为剖析
当客户端未通过 HELLO 命令声明 RESP3 能力（即未发送 HELLO 3），Redis 服务器将强制启用协议降级模式，对 RESP3 特有类型进行语义兼容转换：
map→ 降级为嵌套array（键值交替）set→ 降级为扁平arraydouble→ 降级为bulk string（如"3.14159"）bool→ 降级为simple string（"true"/"false"）
降级示例：map 类型处理
# 客户端未声明 RESP3，执行：
> HELLO 2
> HGETALL myhash
1) "a"
2) "1"
3) "b"
4) "2"逻辑分析：
HGETALL在 RESP2 下天然返回偶数长度数组，与 RESP3 的map语义等价但无类型标记；HELLO 2触发服务器禁用map编码，避免解析错误。
降级策略对比表
| 类型 | RESP3 编码 | 降级后编码 | 兼容性保障机制 |
|---|---|---|---|
| map | %2\r\n$1\r\na\r\n:1\r\n$1\r\nb\r\n:2\r\n |
*4\r\n$1\r\na\r\n$1\r\n1\r\n$1\r\nb\r\n$1\r\n2\r\n |
保持键值成对顺序 |
| bool | #t\r\n |
+true\r\n |
+ 前缀确保被 RESP2 解析器忽略为注释 |
graph TD
A[客户端发起连接] --> B{是否发送 HELLO 3?}
B -->|否| C[启用 RESP2 兼容模式]
B -->|是| D[启用完整 RESP3 类型支持]
C --> E[所有 map/set/double/bool 自动转译]4.2 Go客户端解析器因类型标识缺失导致的结构体反序列化panic复现
根本诱因：无类型标记的 JSON 反序列化
当服务端返回泛型响应（如 {"data": {...}}）且未携带 @type 字段时，Go 客户端使用 json.Unmarshal 直接映射到带嵌套接口字段的结构体，触发 interface{} → struct 类型断言失败。
复现代码片段
type Response struct {
Data interface{} `json:"data"`
}
var resp Response
json.Unmarshal([]byte(`{"data":{"id":123}}`), &resp) // ✅ 成功，Data = map[string]interface{}
// 后续强制转换引发 panic：
user := resp.Data.(User) // ❌ panic: interface conversion: interface {} is map[string]interface {}, not User逻辑分析：
Data字段声明为interface{}，JSON 解析器默认填充为map[string]interface{}；User是具名结构体，二者无隐式转换路径。参数resp.Data实际类型在运行时不可知，缺乏类型标识（如@type: "User"）导致断言必然失败。
典型错误场景对比
| 场景 | 是否含 @type |
反序列化目标 | 结果 |
|---|---|---|---|
无类型字段 + interface{} |
❌ | resp.Data.(User) |
panic |
有 @type:"User" + 自定义 UnmarshalJSON |
✅ | 动态实例化 User |
✅ |
修复路径示意
graph TD
A[原始JSON] --> B{含@type字段？}
B -->|是| C[路由至对应类型Unmarshaler]
B -->|否| D[panic: type assertion failed]4.3 动态类型协商机制：基于CLIENT SETINFO与HELLO命令的运行时能力探测实现
Redis 7.0 引入 HELLO 命令替代旧版 AUTH/SELECT 组合，支持客户端在连接建立后动态声明协议版本、认证凭据及扩展能力。配合 CLIENT SETINFO，服务端可实时感知客户端对 RESP3、client-side caching、tracking 等特性的支持状态。
协商流程示意
graph TD
A[Client connects] --> B[SEND HELLO 3<br>auth:..., clientname:...]
B --> C[Server validates & sets proto=3]
C --> D[Client sends CLIENT SETINFO lib-name redis-py]
D --> E[Server records capability flags]典型能力注册示例
# 客户端主动通告支持 server-assisted client-side caching
CLIENT SETINFO lib-ver 4.5.1
CLIENT SETINFO cap tracking:enabled,cache-responses:truelib-ver：用于服务端做兼容性策略路由（如降级序列化逻辑）cap：以逗号分隔的能力键值对，tracking:enabled触发服务端开启 key-level tracking 上下文
能力元数据存储结构（服务端视角）
| 字段 | 类型 | 说明 |
|---|---|---|
| client_proto | uint8 | 实际生效的 RESP 版本 |
| caps | sds[] | 动态解析的 capability 列表 |
| tracking_ctx | void* | 按需分配的 tracking 上下文指针 |
4.4 降级兜底策略：RESP3→RESP2类型映射表与泛型Unmarshaler统一接口设计
当 Redis 服务器降级至 RESP2 协议时，客户端需将 RESP3 新增的%（map）、~（set）、=（push）等类型安全回退为 RESP2 兼容结构（如数组或字符串）。
类型映射核心规则
RESP3 Map (%)→RESP2 nested array（[["k1","v1"],["k2","v2"]]）RESP3 Set (~)→RESP2 array（["a","b","c"]）RESP3 Push (=)→RESP2 bulk string array（["message","channel"]）
泛型 Unmarshaler 接口设计
type Unmarshaler[T any] interface {
UnmarshalRESP(resp []byte, protocolVersion int) (T, error)
}逻辑分析：
protocolVersion参数驱动分支路由；resp为原始字节流，避免预解析开销；返回值T支持零值安全构造，适配map[string]any、[]any等降级目标类型。
| RESP3 Type | RESP2 Fallback | Lossless? |
|---|---|---|
% (Map) |
[["k","v"],...] |
✅ |
~ (Set) |
["a","b",...] |
❌（无序性保留，但去重语义丢失） |
graph TD
A[Incoming RESP3 Frame] --> B{Protocol Version == 3?}
B -->|Yes| C[Direct Parse]
B -->|No| D[Apply Mapping Table]
D --> E[Convert %→Array, ~→Array, =→Array]
E --> F[Invoke Generic Unmarshaler]第五章：从协议陷阱到高可靠Redis客户端的演进路径
协议解析的隐性雷区
早期团队在自研轻量客户端时，曾忽略 RESP 协议中批量回复（*n\r\n）与空数组边界处理。某次灰度发布后，当 Redis 返回 *0\r\n（空数组）时，客户端因未校验长度字段直接跳过后续解析，导致后续所有响应错位——一个 GET key 的 +OK\r\n 被误读为数组元素，引发全链路数据错乱。该问题仅在特定缓存穿透场景下复现，耗时36小时定位至 readBulkString() 中对 -1 长度的 nil 值未做协议对齐重置。
连接生命周期失控实录
生产环境出现连接数持续攀升至 65535 上限，netstat -an | grep :6379 | wc -l 输出超 6 万。排查发现客户端未启用连接池的 maxIdleTime，且 close() 调用被包裹在 try-catch 中却未打印异常堆栈。最终定位到 SSL 握手超时后，连接对象进入半关闭状态，但连接池误判为“可用”并反复复用，形成 TIME_WAIT 泄漏。修复方案强制注入 SO_LINGER 并增加连接健康探针：
JedisPoolConfig config = new JedisPoolConfig();
config.setTestOnBorrow(true);
config.setTestWhileIdle(true);
config.setTimeBetweenEvictionRunsMillis(30000);故障转移中的脑裂陷阱
集群模式下，某次主从切换期间，客户端因未监听 ASKING 重定向指令，将 ASK 12345 10.0.1.5:6379 响应误作业务错误丢弃，导致写请求永久丢失。后续升级采用 Lettuce 的 StatefulRedisClusterConnection，其自动处理 MOVED/ASK 重定向，并通过 ClusterTopologyRefreshOptions 启用定时拓扑刷新：
| 刷新策略 | 触发条件 | 默认间隔 | 生产调整值 |
|---|---|---|---|
| 自动刷新 | 拓扑变更事件 | — | 启用 |
| 定时刷新 | 固定周期 | 60s | 15s |
| 手动刷新 | API 显式调用 | — | 运维平台集成 |
熔断与降级的协同设计
在电商大促期间，Redis 响应 P99 延迟突破 800ms。原客户端仅依赖超时机制，导致线程池积压。新架构引入 Resilience4j 的 RateLimiter + CircuitBreaker 组合策略：当失败率超 40% 持续 60 秒，熔断器开启；同时启用本地 Caffeine 缓存作为降级源，CacheLoader 设置 refreshAfterWrite(30s) 保证最终一致性。监控数据显示，熔断期间核心接口成功率从 58% 提升至 99.2%。
字节码增强的可观测性实践
为追踪协议层耗时，采用 ByteBuddy 对 io.lettuce.core.protocol.CommandHandler 的 decode 方法进行无侵入埋点，捕获每个 RESP 元素解析耗时，并通过 OpenTelemetry 上报至 Prometheus。关键指标包括 redis_resp_decode_duration_seconds_bucket 和 redis_command_retry_total，支撑 SLO 计算：过去 30 天协议解析错误率稳定在 0.0017%。
连接雪崩的防御性握手
某次机房网络抖动导致 300+ 实例同时触发重连风暴。新客户端实现指数退避重连（初始 100ms，最大 30s），并在 connect() 前校验本地 DNS 缓存 TTL，避免 DNS 查询放大。同时引入连接预热机制：服务启动后异步建立 5 条空闲连接并执行 PING，确保连接池初始化完成后再接收流量。
客户端版本兼容性矩阵
| Redis 版本 | Lettuce 6.1.x | Jedis 4.2.x | 推荐场景 |
|---|---|---|---|
| 6.2 | ✅ 全特性支持 | ⚠️ 不支持 ACL LOG | 集群+ACL |
| 7.0 | ✅ 支持 CLIENT TRACKING | ❌ 无跟踪API | 实时推送 |
| 7.2 | ✅ 支持 SORT_RO | ❌ SORT 不区分RO/RW | 只读排序 |
分布式锁的原子性加固
基于 SET key value EX seconds NX 实现的分布式锁，在 Redis 主从异步复制下出现锁失效。新方案改用 Redisson 的 RLock，其底层通过 Lua 脚本保证加锁/续期/释放的原子性，并集成 watchdog 机制自动续期，同时设置 leaseTime=30s 防止死锁。压测显示锁获取成功率从 92.4% 提升至 99.997%。
