Redis打开泛型的大门（redis 泛型）

Redis：打开泛型的大门

Redis是一个基于内存的键值对存储系统，它提供了丰富的数据结构，如字符串、哈希表、列表、集合和有序集合等。而随着Redis的发展，越来越多的应用场景需要支持更加灵活的数据类型，此时泛型就成了一种弥补Redis不足的解决方案。

Redis中的数据结构使用时需要指定数据类型，而泛型则可以解决这个问题。通过RedisModule_CreateDataType函数，可以创建一个泛型数据类型，这个函数包含了一些用于定义泛型数据类型的参数，如名称、长度、创建函数等。

以下是创建一个简单泛型数据类型的示例：

“`c

#define MY_TYPE “my_type”

typedef struct {

int counter;

} MyType;

static void* MyType_rdb_load(RedisModuleIO *rdb, int encver) {

MyType *mt = RedisModule_Calloc(1, sizeof(*mt));

mt->counter = RedisModule_LoadUnsigned(rdb);

return mt;

}

static void MyType_rdb_save(RedisModuleIO *rdb, void *value) {

MyType *mt = (MyType*)value;

RedisModule_SaveUnsigned(rdb, mt->counter);

}

static void MyType_free(void *value) {

RedisModule_Free(value);

}

static RedisModuleTypeMethods MyType_methods = {

.version = REDISMODULE_TYPE_METHOD_VERSION,

.rdb_load = MyType_rdb_load,

.rdb_save = MyType_rdb_save,

.free = MyType_free,

};

static RedisModuleType *MyType_type;

MyType* MyType_Create(void) {

MyType *mt = RedisModule_Calloc(1, sizeof(*mt));

mt->counter = 0;

return mt;

}

static int MyType_CreateCmd(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {

if (argc != 2) {

return RedisModule_WrongArity(ctx);

}

RedisModule_AutoMemory(ctx);

RedisModuleString *key = argv[1];

if (RedisModule_KeyType(key) != REDISMODULE_KEYTYPE_EMPTY) {

return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);

}

MyType *mt = MyType_Create();

RedisModuleKey *k = RedisModule_OpenKey(ctx, key, REDISMODULE_WRITE);

RedisModule_ModuleTypeSetValue(k, MyType_type, mt);

RedisModule_ReplyWithSimpleString(ctx, “OK”);

return REDISMODULE_OK;

}

int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {

if (RedisModule_Init(ctx, “my_module”, 1, REDISMODULE_APIVER_1) == REDISMODULE_ERR) {

return REDISMODULE_ERR;

}

MyType_type = RedisModule_CreateDataType(ctx, MY_TYPE, 0, &MyType_methods);

RedisModule_CreateCommand(ctx, “mytype.create”, MyType_CreateCmd, “”, 1, 1, 1);

return REDISMODULE_OK;

}

在示例代码中，我们创建了一个名为"MyType"的泛型数据类型，大小为"0"，并定义了MyType_rdb_load、MyType_rdb_save和MyType_free等三个与持久化相关的函数。同时，我们也定义了一个名为"MyType_Create"的函数用于创建泛型数据类型的实例，并在MyType_CreateCmd函数中将它绑定到Redis中的一个key上。我们通过MyType_CreateCommand函数将命令"mytype.create"注册到Redis中。

使用泛型的好处在于，我们不必针对每种Redis数据类型都写相应的代码，只需要使用固定的泛型接口就可以实现通用的存储和查询等操作。例如，可以利用泛型来创建一个包含Redis中所有数据类型的集合，并对该集合进行增删改查等操作。

```c
RedisModuleType *myset_type;
typedef struct {
    void *set;
} MySet;

...

static int MySet_CreateCmd(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) {
        return RedisModule_WrongArity(ctx);
    }
    RedisModule_AutoMemory(ctx);

    RedisModuleString *key = argv[1];

    if (RedisModule_KeyType(key) != REDISMODULE_KEYTYPE_EMPTY) {
        return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);
    }

    MySet *ms = RedisModule_Calloc(1, sizeof(*ms));
    ms->set = RedisModule_CreateDict(NULL);
    RedisModuleKey *k = RedisModule_OpenKey(ctx, key, REDISMODULE_WRITE);
    RedisModule_ModuleTypeSetValue(k, myset_type, ms);
    RedisModule_ReplyWithSimpleString(ctx, "OK");

    return REDISMODULE_OK;
}
static int MySet_AddCmd(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 3) {
        return RedisModule_WrongArity(ctx);
    }
    RedisModule_AutoMemory(ctx);

    RedisModuleString *key = argv[1];
    RedisModuleString *value = argv[2];
    MySet *ms = RedisModule_ModuleTypeGetValue(key);

    if (ms == NULL) {
        return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);
    }

    RedisModuleDict *d = ms->set;

    if (RedisModule_DictReplace(d, value, NULL) == REDISMODULE_ERR) {
        return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);
    }

    RedisModule_ReplyWithSimpleString(ctx, "OK");

    return REDISMODULE_OK;
}
static int MySet_SizeCmd(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) {
        return RedisModule_WrongArity(ctx);
    }
    RedisModule_AutoMemory(ctx);

    RedisModuleString *key = argv[1];

    MySet *ms = RedisModule_ModuleTypeGetValue(key);

    if (ms == NULL) {
        return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);
    }

    RedisModuleDict *d = ms->set;

    RedisModule_ReplyWithLongLong(ctx, RedisModule_DictSize(d));

    return REDISMODULE_OK;
}
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    ...
    myset_type = RedisModule_CreateDataType(ctx, "myset", 0, &MyType_methods);

    RedisModule_CreateCommand(ctx, "mysset.create", MySet_CreateCmd, "", 1, 1, 1);
    RedisModule_CreateCommand(ctx, "myset.add", MySet_AddCmd, "", 2, 2, 1);
    RedisModule_CreateCommand(ctx, "myset.size", MySet_SizeCmd, "", 1, 1, 1);

    return REDISMODULE_OK;
}

在上述代码中，我们创建了一个名为”MySet”的泛型数据类型，大小为”0″，并定义了一个名为MySet的结构体，其中包含一个RedisModuleDict类型的成员变量”set”。这里RedisModuleDict可以看作是一个泛型的哈希表，用于存储任意类型的数据。通过MySet_CreateCmd函数，我们在Redis中注册了一个”myset.create”的命令，将创建一个MySet实例并绑定到Redis的key上。通过MySet_AddCmd和MySet_SizeCmd函数，我们则可以对MySet实例进行增删改查等操作。

总体来说，使用泛型可以让Redis支持更加灵活的数据操作，减少代码量和复杂度。但同时由于泛型的通用性，也可能牺牲一些性能，需要根据实际情况进行选择。