插件系统 - Redis 学习教程

📦 知名 Redis 模块

🔍

RediSearch

强大的全文搜索引擎，支持二级索引、模糊搜索、向量相似度搜索等。

▼ 展开

📌 核心功能

全文搜索和聚合查询
向量相似度搜索（VSS）
JSON 文档索引
地理空间搜索
自动补全建议

💻 使用示例

# 创建索引
FT.CREATE idx:product ON JSON PREFIX 1 product: SCHEMA \
  $.name AS name TEXT \
  $.price AS price NUMERIC \
  $.category AS category TAG

# 搜索产品
FT.SEARCH idx:product "@category:{electronics} @price:[0 1000]"

# 向量搜索
FT.SEARCH idx:products "*=>[KNN 10 @vector $BLOB]" PARAMS 2 BLOB [blob]
                        

📥 安装方式

# Docker 方式
docker run -p 6379:6379 redis/redis-stack-server:latest

# 或加载模块
redis-server --loadmodule /path/to/redisearch.so
                        

官方文档 →

📋

RedisJSON

原生 JSON 数据类型支持，允许在 Redis 中存储、查询和操作 JSON 文档。

▼ 展开

📌 核心功能

JSONPath 查询语法
原子级字段操作
支持数组操作
与 RediSearch 集成
Schema 验证

💻 使用示例

# 设置 JSON 文档
JSON.SET user:1001 $ '{"name":"张三","age":30,"hobbies":["读书","游泳"]}'

# 获取字段
JSON.GET user:1001 $.name
> ["张三"]

# 更新字段
JSON.SET user:1001 $.age 31

# 数组操作
JSON.ARRAPPEND user:1001 $.hobbies '"旅行"'

# 删除字段
JSON.DEL user:1001 $.age
                        

📥 安装方式

# Redis Stack 已内置
docker run -p 6379:6379 redis/redis-stack-server:latest

# 单独加载模块
redis-server --loadmodule /path/to/rejson.so
                        

官方文档 →

📈

RedisTimeSeries

时间序列数据存储和查询模块，适用于 IoT、监控、金融等场景。

▼ 展开

📌 核心功能

高效时间序列存储
自动降采样（Downsampling）
聚合查询（AVG、SUM、MAX 等）
数据保留策略
标签索引和过滤

💻 使用示例

# 创建时间序列
TS.CREATE temperature:sensor:1 RETENTION 86400000 LABELS sensor_id 1 location 北京

# 添加数据点
TS.ADD temperature:sensor:1 * 25.5 LABELS sensor_id 1

# 范围查询
TS.RANGE temperature:sensor:1 - + AGGREGATION AVG 3600000

# 多序列查询
TS.MRANGE - + FILTER location=北京 AGGREGATION AVG 3600000

# 创建降采样规则
TS.CREATERULE temperature:sensor:1 temperature:avg AGGREGATION AVG 3600000
                        

📥 安装方式

# Redis Stack 已内置
docker run -p 6379:6379 redis/redis-stack-server:latest

# 单独加载模块
redis-server --loadmodule /path/to/redistimeseries.so
                        

官方文档 →

🕸️

RedisGraph

图数据库模块，使用 Cypher 查询语言，支持关系数据的存储和查询。

▼ 展开

📌 核心功能

Cypher 查询语言支持
属性图模型
矩阵乘法优化
关系遍历查询
路径查找算法

💻 使用示例

# 创建节点
GRAPH.QUERY social "CREATE (:Person {name:'张三', age:30})"

# 创建关系
GRAPH.QUERY social "MATCH (a:Person {name:'张三'}), (b:Person {name:'李四'}) CREATE (a)-[:FRIEND]->(b)"

# 查询朋友
GRAPH.QUERY social "MATCH (p:Person {name:'张三'})-[:FRIEND]->(f) RETURN f.name"

# 复杂查询
GRAPH.QUERY social "MATCH (p:Person)-[:FRIEND*2..3]->(f) RETURN p.name, f.name"
                        

📥 安装方式

# Docker 方式
docker run -p 6379:6379 redisgraph/redisgraph

# 加载模块
redis-server --loadmodule /path/to/redisgraph.so
                        

官方文档 →

🌺

RedisBloom

概率数据结构集合，包括布隆过滤器、计数布隆过滤器、Cuckoo 过滤器等。

▼ 展开

📌 核心功能

布隆过滤器（Bloom Filter）
计数布隆过滤器
Cuckoo 过滤器
Top-K 算法
HyperLogLog 增强

💻 使用示例

# 创建布隆过滤器
BF.RESERVE mybloom 0.01 1000

# 添加元素
BF.ADD mybloom user123

# 检查元素是否存在
BF.EXISTS mybloom user123
> 1 (可能存在)

# Top-K 统计
TOPK.ADD mytopk item1 item2 item3
TOPK.LIST mytopk
> ["item1", "item2", "item3"]

# Cuckoo 过滤器
CF.ADD mycf product456
CF.EXISTS mycf product456
                        

📥 安装方式

# Redis Stack 已内置
docker run -p 6379:6379 redis/redis-stack-server:latest

# 单独加载模块
redis-server --loadmodule /path/to/redisbloom.so
                        

官方文档 →

⚡

RedisCell

分布式限流模块，实现令牌桶算法，用于 API 限流和速率控制。

▼ 展开

📌 核心功能

令牌桶算法实现
分布式限流
精确的速率控制
原子操作保证
灵活的配置选项

💻 使用示例

# 限流配置：每秒 10 个请求，桶容量 20
CL.THROTTLE user:123 10 20 1

# 返回值：[是否允许，剩余容量，重置时间，重试延迟]
> [0, 19, 20, 0]  # 允许

# 超过限制
CL.THROTTLE user:123 10 20 1
> [1, 0, 20, 1]   # 拒绝，1 秒后重试

# 检查当前状态
CL.THROTTLE user:123 10 20 1 0
                        

📥 安装方式

# 编译安装
git clone https://github.com/brandur/redis-cell
cd redis-cell
cargo build --release

# 加载模块
redis-server --loadmodule target/release/libredis_cell.so
                        

GitHub →

🤖

RedisAI

深度学习推理模块，支持在 Redis 中运行 AI 模型，实现实时推理。

▼ 展开

📌 核心功能

支持 TensorFlow、PyTorch、ONNX 等框架
模型存储和管理
实时推理执行
脚本执行（TorchScript）
张量数据类型支持
模型版本管理

💻 使用示例

# 设置模型
AI.MODELSTORE mymodel TF CPU TAGS image classifier \
  INPUTS 1 blobs INPUT \
  OUTPUTS 1 OUTPUT \
  BLOB [model_binary]

# 设置输入数据
AI.TENSORSET INPUT FLOAT 1 224 224 3 [data...]

# 运行推理
AI.MODELRUN mymodel INPUTS INPUT OUTPUTS OUTPUT

# 获取结果
AI.TENSORGET OUTPUT
                        

📥 安装方式

# Docker 方式（推荐）
docker run -p 6379:6379 redisai/redisai:latest

# 或从源码编译
git clone https://github.com/RedisAI/RedisAI
cd RedisAI
make
                        

官方文档 →

⚙️

RedisGears

无服务器计算框架，支持在 Redis 上运行自定义逻辑和数据处理。

▼ 展开

📌 核心功能

事件驱动的函数执行
支持 Python 和 JavaScript
键空间事件触发
定时任务调度
流数据处理
分布式执行

💻 使用示例

# 注册键空间事件触发器
GearsBuilder() \
    .filter(lambda x: x['key'].startswith('user:')) \
    .map(lambda x: executeCommand('INCR', 'user:count')) \
    .register()

# 定时任务
GearsBuilder('KeySpaceNotification') \
    .timeTrigger('1000', lambda x: executeCommand('PING')) \
    .register()

# 流处理
GearsBuilder('StreamReader') \
    .flatmap(lambda x: x['records']) \
    .run('mystream')
                        

📥 安装方式

# Docker 方式
docker run -p 6379:6379 redisfab/redisgears:latest

# 或加载模块
redis-server --loadmodule /path/to/redisgears.so \
  --plugin /path/to/js_plugin.so
                        

官方文档 →

🧠

redis-ml

机器学习模块，提供经典 ML 算法的 Redis 实现，支持在 Redis 中进行模型训练和预测。

▼ 展开

📌 核心功能

K-means 聚类分析
线性回归（Linear Regression）
逻辑回归（Logistic Regression）
决策树（Decision Tree）
随机森林（Random Forest）
支持向量机（SVM）
特征工程支持
模型持久化和版本管理
实时预测推理

💻 使用示例 - K-means 聚类

# 创建 K-means 模型：3 个簇，2 维特征
ML.KMEANS.CREATE kmeans_model 3 2

# 添加训练数据点
ML.KMEANS.ADD kmeans_model [1.0, 2.0] [1.5, 1.8] [5.0, 8.0] [8.0, 8.0] [1.0, 0.6] [9.0, 11.0]

# 训练模型
ML.KMEANS.TRAIN kmeans_model ITERATIONS 100

# 预测新数据点属于哪个簇
ML.KMEANS.PREDICT kmeans_model [2.0, 3.0]
> 0  # 返回簇 ID

# 获取聚类中心
ML.KMEANS.CENTERS kmeans_model
> 1) [1.17, 1.47]  # 簇 0 中心
   2) [7.50, 8.00]  # 簇 1 中心
   3) [9.00, 11.0]  # 簇 2 中心

# 获取模型信息
ML.KMEANS.INFO kmeans_model
                        

💻 使用示例 - 线性回归

# 创建线性回归模型：1 个特征（房屋面积），预测目标（房价）
ML.LR.CREATE house_price_model 1

# 添加训练数据：[面积] -> 价格
ML.LR.ADD house_price_model [50] 150000
ML.LR.ADD house_price_model [80] 240000
ML.LR.ADD house_price_model [100] 300000
ML.LR.ADD house_price_model [120] 360000
ML.LR.ADD house_price_model [150] 450000

# 训练模型
ML.LR.TRAIN house_price_model

# 预测：130 平米的房子价格
ML.LR.PREDICT house_price_model [130]
> 390000  # 预测价格

# 获取模型系数（斜率和截距）
ML.LR.COEFFICIENTS house_price_model
> [3000, 0]  # 每平米 3000 元

# 模型评估
ML.LR.SCORE house_price_model
> R² = 0.998  # 拟合度很高
                        

💻 使用示例 - 逻辑回归（分类）

# 创建逻辑回归模型：2 个特征（年龄、收入），二分类
ML.LOGR.CREATE user_churn_model 2

# 添加训练数据：[年龄，收入] -> 是否流失 (0/1)
ML.LOGR.ADD user_churn_model [25, 5000] 0  # 未流失
ML.LOGR.ADD user_churn_model [30, 8000] 0
ML.LOGR.ADD user_churn_model [45, 12000] 1  # 流失
ML.LOGR.ADD user_churn_model [50, 15000] 1
ML.LOGR.ADD user_churn_model [35, 6000] 0
ML.LOGR.ADD user_churn_model [55, 20000] 1

# 训练模型
ML.LOGR.TRAIN user_churn_model ITERATIONS 1000 LEARNING_RATE 0.01

# 预测：35 岁，收入 7000 的用户
ML.LOGR.PREDICT user_churn_model [35, 7000]
> 0  # 预测不会流失

# 获取预测概率
ML.LOGR.PROBABILITY user_churn_model [35, 7000]
> 0.23  # 23% 的流失概率

# 获取模型权重
ML.LOGR.WEIGHTS user_churn_model
                        

💻 使用示例 - 决策树

# 创建决策树分类器：3 个特征
ML.DT.CREATE dt_model 3 CLASSES 2

# 添加训练数据：[特征 1, 特征 2, 特征 3] -> 类别
ML.DT.ADD dt_model [1, 0, 1] 0
ML.DT.ADD dt_model [0, 1, 0] 1
ML.DT.ADD dt_model [1, 1, 0] 0
ML.DT.ADD dt_model [0, 0, 1] 1
ML.DT.ADD dt_model [1, 0, 0] 0
ML.DT.ADD dt_model [0, 1, 1] 1

# 训练决策树
ML.DT.TRAIN dt_model MAX_DEPTH 5

# 预测
ML.DT.PREDICT dt_model [1, 0, 1]
> 0

# 获取特征重要性
ML.DT.FEATURE_IMPORTANCE dt_model
> [0.5, 0.3, 0.2]  # 特征 1 最重要

# 导出决策树结构（JSON 格式）
ML.DT.TREE dt_model
                        

💻 使用示例 - 模型管理

# 保存模型到持久化存储
ML.MODEL.SAVE kmeans_model /path/to/models/kmeans.rdb

# 从文件加载模型
ML.MODEL.LOAD kmeans_model_v2 /path/to/models/kmeans.rdb

# 列出所有模型
ML.MODEL.LIST
> 1) "kmeans_model"
   2) "house_price_model"
   3) "user_churn_model"

# 删除模型
ML.MODEL.DELETE old_model

# 导出模型为 PMML 格式（可与其他系统互操作）
ML.MODEL.EXPORT kmeans_model PMML /path/to/export.xml

# 模型版本管理
ML.MODEL.VERSION kmeans_model
> 1.0.2
                        

📥 安装方式

# 从源码编译
git clone https://github.com/RedisAI/redis-ml
cd redis-ml

# 安装依赖
pip install -r requirements.txt

# 编译
make

# 加载模块
redis-server --loadmodule target/release/redis_ml.so

# Docker 方式（推荐）
docker run -p 6379:6379 redisai/redis-ml:latest
                        

GitHub →

🎯 应用场景

用户分群：基于行为数据进行客户细分
销售预测：根据历史数据预测未来销售额
风险评估：信用评分和欺诈检测
推荐系统：用户兴趣聚类和物品分类
异常检测：识别异常数据点
实时决策：在线预测和分类

📊

redis-count-min-sketch

计数最小草图模块，用于高效统计频率。

▼ 展开

📌 核心功能

空间高效的频率统计
可配置的精度
支持合并多个草图
适合大数据集
低内存占用

💻 使用示例

# 创建草图
CMS.INIT mycms 1000 5  # 宽度 1000，深度 5

# 增加计数
CMS.INCRBY mycms item1 1
CMS.INCRBY mycms item2 5

# 查询计数
CMS.QUERY mycms item1 item2
> 1 5

# 合并草图
CMS.MERGE dest 2 src1 src2 WEIGHTS 1 2
                        

📥 安装方式

# 已包含在 RedisBloom 中
# 单独模块已不再维护

# 使用 RedisBloom
docker run -p 6379:6379 redis/redis-stack-server:latest
                        

RedisBloom 文档 →

🔢

redis-hyperloglog

HyperLogLog 基数计数模块，用于唯一值统计。

▼ 展开

📌 核心功能

超低内存占用
基数估算（唯一值数量）
标准误差约 0.81%
支持合并多个 HLL
固定 12KB 内存

💻 使用示例

# 添加元素
PFADD hll user1 user2 user3
> 1  # 首次添加返回 1

PFADD hll user2 user3 user4
> 1  # 有新元素

# 计数
PFCOUNT hll
> 4  # 估算的唯一值数量

# 合并多个 HLL
PFMERGE dest hll1 hll2
PFCOUNT dest
                        

📥 安装方式

# HyperLogLog 是 Redis 原生功能
# 无需额外模块，Redis 2.8.9+ 已支持

# 直接使用
redis-cli
127.0.0.1:6379> PFADD myhll item1 item2
                        

官方文档 →

🛠️ 模块开发指南

环境准备

▼ 展开

安装开发工具

# Ubuntu/Debian
sudo apt-get install build-essential autoconf automake libtool

# macOS
xcode-select --install
brew install autoconf automake libtool

# 安装 Redis 源码（获取头文件）
git clone https://github.com/redis/redis.git
cd redis
make
                            

项目结构

my-module/
├── src/
│   └── mymodule.c      # 模块源代码
├── Makefile            # 构建配置
├── README.md           # 说明文档
└── tests/              # 测试文件
                            

创建第一个模块

▼ 展开

基础模块模板

#include "redismodule.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 命令实现：HELLO.WORLD
int HelloWorld_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    // 检查参数数量
    if (argc != 1) {
        return RedisModule_WrongArity(ctx);
    }
    
    // 返回简单字符串
    RedisModule_ReplyWithSimpleString(ctx, "Hello, Redis Module World!");
    return REDISMODULE_OK;
}

// 命令实现：HELLO.ECHO <message>
int HelloEcho_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) {
        return RedisModule_WrongArity(ctx);
    }
    
    // 返回传入的消息
    RedisModule_ReplyWithString(ctx, argv[1]);
    return REDISMODULE_OK;
}

// 模块加载入口
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    // 初始化模块 API
    if (RedisModule_Init(ctx, "hello", 1, REDISMODULE_APIVER_1) == REDISMODULE_ERR) {
        return REDISMODULE_ERR;
    }
    
    // 注册命令
    if (RedisModule_CreateCommand(ctx, "hello.world", HelloWorld_RedisCommand, 
                                   "readonly", 0, 0, 0) == REDISMODULE_ERR) {
        return REDISMODULE_ERR;
    }
    
    if (RedisModule_CreateCommand(ctx, "hello.echo", HelloEcho_RedisCommand, 
                                   "readonly", 0, 0, 0) == REDISMODULE_ERR) {
        return REDISMODULE_ERR;
    }
    
    return REDISMODULE_OK;
}
                            

编译模块

▼ 展开

Makefile 配置

# Makefile
MODULE_NAME = hello
MODULE_TARGET = $(MODULE_NAME).so

# Redis 源码路径
REDIS_SRC = ../redis/src

# 编译器设置
CC = gcc
CFLAGS = -fPIC -O2 -I$(REDIS_SRC)
LDFLAGS = -shared

# 源文件
SRCS = src/mymodule.c

# 默认目标
all: $(MODULE_TARGET)

# 编译模块
$(MODULE_TARGET): $(SRCS)
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^

# 清理
clean:
	rm -f $(MODULE_TARGET)

# 安装
install: $(MODULE_TARGET)
	cp $(MODULE_TARGET) /usr/local/lib/redis/modules/

.PHONY: all clean install
                            

编译命令

# 编译模块
make

# 输出：hello.so
                            

加载和测试

▼ 展开

启动 Redis 并加载模块

# 方式 1：启动时加载
redis-server --loadmodule ./hello.so

# 方式 2：运行时动态加载
redis-cli
127.0.0.1:6379> MODULE LOAD ./hello.so
OK

# 方式 3：使用配置文件
# 在 redis.conf 中添加：
# loadmodule /path/to/hello.so
redis-server redis.conf
                            

测试命令

# 测试命令
127.0.0.1:6379> HELLO.WORLD
"Hello, Redis Module World!"

127.0.0.1:6379> HELLO.ECHO "测试消息"
"测试消息"

# 查看模块信息
127.0.0.1:6379> MODULE LIST
1) 1) "name"
   2) "hello"
   3) "ver"
   4) (integer) 1

# 卸载模块
127.0.0.1:6379> MODULE UNLOAD hello
OK
                            

创建自定义数据类型

▼ 展开

自定义类型示例：计数器

#include "redismodule.h"
#include <stdlib.h>

// 自定义数据类型结构
typedef struct {
    long long value;
    long long timestamp;
} CounterObject;

// 全局类型引用
RedisModuleType *CounterType;

// 创建对象
CounterObject *createCounterObject(long long initialValue) {
    CounterObject *co = RedisModule_Alloc(sizeof(CounterObject));
    co->value = initialValue;
    co->timestamp = time(NULL);
    return co;
}

// RDB 序列化（持久化）
void counterRDBSave(RedisModuleIO *rdb, void *value) {
    CounterObject *co = value;
    RedisModule_SaveSigned(rdb, co->value);
    RedisModule_SaveSigned(rdb, co->timestamp);
}

// RDB 反序列化（加载）
void *counterRDBLoad(RedisModuleIO *rdb, int encver) {
    if (encver != 0) {
        return NULL;
    }
    CounterObject *co = RedisModule_Alloc(sizeof(CounterObject));
    co->value = RedisModule_LoadSigned(rdb);
    co->timestamp = RedisModule_LoadSigned(rdb);
    return co;
}

// AOF 重写
void counterAOFRewrite(RedisModuleIO *aof, RedisModuleString *key, void *value) {
    CounterObject *co = value;
    RedisModule_EmitAOF(aof, "COUNTER.SET", "sls", key, co->value);
}

// 内存使用统计
size_t counterMemUsage(const void *value) {
    return sizeof(CounterObject);
}

// 释放对象
void counterFree(void *value) {
    RedisModule_Free(value);
}

// COUNTER.CREATE <key> [initial_value]
int CounterCreate_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc < 2 || argc > 3) {
        return RedisModule_WrongArity(ctx);
    }
    
    long long initialValue = 0;
    if (argc == 3) {
        if (RedisModule_StringToLongLong(argv[2], &initialValue) != REDISMODULE_OK) {
            RedisModule_ReplyWithError(ctx, "ERR invalid initial value");
            return REDISMODULE_ERR;
        }
    }
    
    RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_WRITE);
    
    if (RedisModule_KeyType(key) != REDISMODULE_KEYTYPE_EMPTY) {
        RedisModule_ReplyWithError(ctx, "ERR key already exists");
        return REDISMODULE_ERR;
    }
    
    CounterObject *co = createCounterObject(initialValue);
    RedisModule_ModuleTypeSetValue(key, CounterType, co);
    
    RedisModule_ReplyWithSimpleString(ctx, "OK");
    return REDISMODULE_OK;
}

// COUNTER.GET <key>
int CounterGet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) {
        return RedisModule_WrongArity(ctx);
    }
    
    RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_READ);
    
    if (RedisModule_KeyType(key) == REDISMODULE_KEYTYPE_EMPTY) {
        RedisModule_ReplyWithError(ctx, "ERR no such key");
        return REDISMODULE_ERR;
    }
    
    if (RedisModule_ModuleTypeGetType(key) != CounterType) {
        RedisModule_ReplyWithError(ctx, "ERR wrong type");
        return REDISMODULE_ERR;
    }
    
    CounterObject *co = RedisModule_ModuleTypeGetValue(key);
    RedisModule_ReplyWithLongLong(ctx, co->value);
    return REDISMODULE_OK;
}

// COUNTER.INCR <key> [by]
int CounterIncr_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc < 2 || argc > 3) {
        return RedisModule_WrongArity(ctx);
    }
    
    long long increment = 1;
    if (argc == 3) {
        if (RedisModule_StringToLongLong(argv[2], &increment) != REDISMODULE_OK) {
            RedisModule_ReplyWithError(ctx, "ERR invalid increment");
            return REDISMODULE_ERR;
        }
    }
    
    RedisModuleKey *key = RedisModule_OpenKey(ctx, argv[1], REDISMODULE_WRITE);
    
    if (RedisModule_KeyType(key) == REDISMODULE_KEYTYPE_EMPTY) {
        RedisModule_ReplyWithError(ctx, "ERR no such key");
        return REDISMODULE_ERR;
    }
    
    if (RedisModule_ModuleTypeGetType(key) != CounterType) {
        RedisModule_ReplyWithError(ctx, "ERR wrong type");
        return REDISMODULE_ERR;
    }
    
    CounterObject *co = RedisModule_ModuleTypeGetValue(key);
    co->value += increment;
    
    RedisModule_ReplyWithLongLong(ctx, co->value);
    return REDISMODULE_OK;
}

// 模块加载入口
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (RedisModule_Init(ctx, "counter", 1, REDISMODULE_APIVER_1) == REDISMODULE_ERR) {
        return REDISMODULE_ERR;
    }
    
    // 注册数据类型
    RedisModuleTypeMethods tm = {
        .version = REDISMODULE_TYPE_METHOD_VERSION,
        .rdb_load = counterRDBLoad,
        .rdb_save = counterRDBSave,
        .aof_rewrite = counterAOFRewrite,
        .free = counterFree,
        .mem_usage = counterMemUsage
    };
    
    CounterType = RedisModule_CreateDataType(ctx, "counter_t", 0, &tm);
    if (CounterType == NULL) {
        return REDISMODULE_ERR;
    }
    
    // 注册命令
    if (RedisModule_CreateCommand(ctx, "counter.create", CounterCreate_RedisCommand, 
                                   "write deny-oom", 0, 0, 0) == REDISMODULE_ERR) return REDISMODULE_ERR;
    if (RedisModule_CreateCommand(ctx, "counter.get", CounterGet_RedisCommand, 
                                   "readonly", 0, 0, 0) == REDISMODULE_ERR) return REDISMODULE_ERR;
    if (RedisModule_CreateCommand(ctx, "counter.incr", CounterIncr_RedisCommand, 
                                   "write", 0, 0, 0) == REDISMODULE_ERR) return REDISMODULE_ERR;
    
    return REDISMODULE_OK;
}
                            

高级特性

▼ 展开

使用 Redis 键空间通知

// 订阅键空间事件
int RedisModule_OnLoad(RedisModuleCtx *ctx, ...) {
    // 订阅过期事件
    if (RedisModule_SubscribeToKeyspaceEvents(ctx, 
        REDISMODULE_NOTIFY_EXPIRED | REDISMODULE_NOTIFY_SET, 
        keySpaceNotification) == REDISMODULE_ERR) {
        return REDISMODULE_ERR;
    }
    return REDISMODULE_OK;
}

void keySpaceNotification(RedisModuleCtx *ctx, int type, const char *event, 
                          RedisModuleString *key) {
    RedisModule_Log(ctx, "notice", "Keyspace event: %s on key %s", event, 
                    RedisModule_StringPtrLen(key, NULL));
}
                            

使用定时器

// 创建定时器
RedisModuleTimerID timerId;

void timerHandler(RedisModuleCtx *ctx, void *data) {
    RedisModule_Log(ctx, "notice", "Timer fired!");
    // 重新注册定时器
    timerId = RedisModule_CreateTimer(ctx, 1000, timerHandler, NULL);
}

// 在模块加载时启动定时器
int RedisModule_OnLoad(...) {
    timerId = RedisModule_CreateTimer(ctx, 1000, timerHandler, NULL);
    return REDISMODULE_OK;
}
                            

线程安全上下文

// 获取线程安全上下文
RedisModuleThreadSafeContext *safeCtx = RedisModule_GetThreadSafeContext(NULL);

// 在后台线程中使用
void *backgroundTask(void *arg) {
    RedisModule_ThreadSafeContextLock(safeCtx);
    // 执行 Redis 操作
    RedisModule_ThreadSafeContextUnlock(safeCtx);
    return NULL;
}

// 释放上下文
RedisModule_FreeThreadSafeContext(safeCtx);
                            

📚 常用模块 API 参考

API 函数	说明	示例
`RedisModule_Init`	初始化模块 API	`RedisModule_Init(ctx, "mymodule", 1, REDISMODULE_APIVER_1)`
`RedisModule_CreateCommand`	注册 Redis 命令	`RedisModule_CreateCommand(ctx, "cmd.name", cmdFunc, "write", 0, 0, 0)`
`RedisModule_ReplyWithSimpleString`	返回简单字符串	`RedisModule_ReplyWithSimpleString(ctx, "OK")`
`RedisModule_ReplyWithLongLong`	返回整数	`RedisModule_ReplyWithLongLong(ctx, 12345)`
`RedisModule_ReplyWithString`	返回 Redis 字符串	`RedisModule_ReplyWithString(ctx, argv[1])`
`RedisModule_OpenKey`	打开键进行操作	`RedisModule_OpenKey(ctx, key, REDISMODULE_WRITE)`
`RedisModule_ModuleTypeSetValue`	设置模块类型值	`RedisModule_ModuleTypeSetValue(key, type, value)`
`RedisModule_CreateDataType`	创建自定义数据类型	`RedisModule_CreateDataType(ctx, "type_name", 0, &tm)`
`RedisModule_Alloc`	分配内存（Redis 托管）	`RedisModule_Alloc(sizeof(MyStruct))`
`RedisModule_Free`	释放内存	`RedisModule_Free(ptr)`
`RedisModule_StringToLongLong`	字符串转整数	`RedisModule_StringToLongLong(str, &value)`
`RedisModule_CreateStringFromString`	创建字符串副本	`RedisModule_CreateStringFromString(ctx, src)`
`RedisModule_Replicate`	复制命令到副本	`RedisModule_Replicate(ctx, "cmd", "args", ...)`
`RedisModule_Log`	记录日志	`RedisModule_Log(ctx, "warning", "Error message")`
`RedisModule_WrongArity`	返回参数错误	`RedisModule_WrongArity(ctx)`

💡 最佳实践

✅ 内存管理

使用 RedisModule_Alloc 而非 malloc
及时释放不再使用的内存
实现 mem_usage 回调报告内存使用
避免内存泄漏

✅ 错误处理

始终检查 API 返回值
使用 RedisModule_ReplyWithError 报告错误
提供清晰的错误信息
处理边界情况

✅ 性能优化

避免在命令中执行耗时操作
使用后台线程处理重任务
合理使用数据结构
减少不必要的内存分配

✅ 线程安全

主线程中执行 Redis 操作
使用 ThreadSafeContext 进行后台操作
正确加锁和解锁
避免死锁

❌ 避免事项

不要阻塞主线程
不要使用标准 C 库分配器
不要直接访问 Redis 内部结构
不要忽略错误返回值

📝 测试建议

编写单元测试覆盖所有命令
测试持久化和 AOF 重写
进行内存泄漏检测
压力测试验证稳定性

📖 学习资源

📦 知名 Redis 模块

RediSearch

📌 核心功能

💻 使用示例

📥 安装方式

RedisJSON

📌 核心功能

💻 使用示例

📥 安装方式

RedisTimeSeries

📌 核心功能

💻 使用示例

📥 安装方式

RedisGraph

📌 核心功能

💻 使用示例

📥 安装方式

RedisBloom

📌 核心功能

💻 使用示例

📥 安装方式

RedisCell

📌 核心功能

💻 使用示例

📥 安装方式

RedisAI

📌 核心功能

💻 使用示例

📥 安装方式

RedisGears

📌 核心功能

💻 使用示例

📥 安装方式

redis-ml

📌 核心功能

💻 使用示例 - K-means 聚类

💻 使用示例 - 线性回归

💻 使用示例 - 逻辑回归（分类）

💻 使用示例 - 决策树

💻 使用示例 - 模型管理

📥 安装方式

🎯 应用场景

redis-count-min-sketch

📌 核心功能

💻 使用示例

📥 安装方式

redis-hyperloglog

📌 核心功能

💻 使用示例

📥 安装方式

🛠️ 模块开发指南

环境准备

安装开发工具

项目结构

创建第一个模块

基础模块模板

编译模块

Makefile 配置

编译命令

加载和测试

启动 Redis 并加载模块

测试命令

创建自定义数据类型

自定义类型示例：计数器

高级特性

使用 Redis 键空间通知

使用定时器

线程安全上下文

📚 常用模块 API 参考

💡 最佳实践

✅ 内存管理

✅ 错误处理

✅ 性能优化

✅ 线程安全

❌ 避免事项

📝 测试建议

📖 学习资源

📄 官方文档

💻 示例代码

📦 Redis Stack