【Redis】客户端使用

秦jh_2026-04-01 17:24

🌈个人主页： 秦jh__https://blog.csdn.net/qinjh_?spm=1010.2135.3001.5343
🔥 系列专栏： https://blog.csdn.net/qinjh_/category_13079918.html

目录

通用命令

set和get

exists和del

keys

expire和ttl

type

string

get和set

mget和mset

getrange和setrange

incr和decr

list

lpush和lrange

rpush、lpop和rpop

blpop

llen

set

sadd和smembers

sismember、spop和scard

sinter和sinterstore

hash

hset和hget

hexists、hdel和hlen

hkeys、hvals、hmset、hmget

zset

zcard、zrem、zscore、zrank

前言

💬 hello! 各位铁子们大家好哇。

今日更新了Redis相关内容

🎉 欢迎大家关注🔍点赞👍收藏⭐️留言📝

通用命令

set和get

cpp 复制代码 
// get 和 set
void test1(sw::redis::Redis& redis) {
    std::cout << "get 和 set 的使用" << std::endl;

    // 清空一下数据库, 避免之前残留的数据有干扰. 
    redis.flushall();

    // 使用 set 设置 key
    redis.set("key1", "111");
    redis.set("key2", "222");
    redis.set("key3", "333");

    // 使用 get 获取到 key 对应的 value
    auto value1 = redis.get("key1");
    // optional 可以隐式转成 bool 类型, 可以直接在 if 中判定. 如果是无效元素, 就是返回 false
    if (value1) {
        std::cout << "value1=" << value1.value() << std::endl;
    }

    auto value2 = redis.get("key2");
    if (value2) {
        std::cout << "value2=" << value2.value() << std::endl;
    }

    auto value3 = redis.get("key3");
    if (value3) {
        std::cout << "value3=" << value3.value() << std::endl;
    }

    auto value4 = redis.get("key4");
    if (value4) {
        std::cout << "value4=" << value4.value() << std::endl;
    }
}

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    test1(redis);

    return 0;
}

exists和del

cpp 复制代码 
void test2(sw::redis::Redis& redis) {
    std::cout << "exists" << std::endl;

    redis.flushall();

    redis.set("key", "111");
    redis.set("key3", "111");

    auto ret = redis.exists("key");
    std::cout << ret << std::endl;

    ret = redis.exists("key2");
    std::cout << ret << std::endl;

    ret = redis.exists({"key", "key2", "key3"});
    std::cout << ret << std::endl;
}

void test3(sw::redis::Redis& redis) {
    std::cout << "del" << std::endl;
    // 清除库非常必要的! 
    redis.flushall();

    redis.set("key", "111");
    redis.set("key2", "111");

    // redis.del("key");

    auto ret = redis.del({"key", "key2", "key3"});
    std::cout << ret << std::endl;

    ret = redis.exists({"key", "key2"});
    std::cout << ret << std::endl;
}

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    test2(redis);
    test3(redis);
    return 0;
}

keys

cpp 复制代码 
void test4(sw::redis::Redis& redis) {
    std::cout << "keys" << std::endl;
    redis.flushall();

    redis.set("key", "111");
    redis.set("key2", "222");
    redis.set("key3", "333");
    redis.set("key4", "444");
    redis.set("key5", "555");
    redis.set("key6", "666");

    // keys 的第二个参数, 是一个 "插入迭代器". 咱们需要先准备好一个保存结果的容器. 
    // 接下来再创建一个插入迭代器指向容器的位置. 就可以把 keys 获取到的结果依次通过刚才的插入迭代器插入到容器的指定位置中了. 
    vector<string> result;
    auto it = std::back_inserter(result);
    redis.keys("*", it);
    printContainer(result);
}

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    test4(redis);
    return 0;
}

expire和ttl

cpp 复制代码 
void test5(sw::redis::Redis& redis) {
    using namespace std::chrono_literals;

    std::cout << "expire and ttl" << std::endl;
    redis.flushall();

    redis.set("key", "111");
    // 10s => std::chrono::seconds(10)
    redis.expire("key", 10s);

    std::this_thread::sleep_for(3s);

    auto time = redis.ttl("key");
    std::cout << time << std::endl;
}

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    // test5(redis);

    return 0;
}

type

cpp 复制代码 
void test6(sw::redis::Redis& redis) {
    std::cout << "type" << std::endl;
    redis.flushall();

    redis.set("key", "111");
    string result = redis.type("key");
    std::cout << "key: " << result << std::endl;

    redis.lpush("key2", "111");
    result = redis.type("key2");
    std::cout << "key2: " << result << std::endl;

    redis.hset("key3", "aaa", "111");
    result = redis.type("key3");
    std::cout << "key3: " << result << std::endl;

    redis.sadd("key4", "aaa");
    result = redis.type("key4");
    std::cout << "key4: " << result << std::endl;

    redis.zadd("key5", "吕布", 99);
    result = redis.type("key5");
    std::cout << "key5: " << result << std::endl;
}

int main() {
    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    test6(redis);

    return 0;
}

string

get和set

cpp 复制代码 
void test1(Redis& redis) {
    std::cout << "get 和 set" << std::endl;
    redis.flushall();

    redis.set("key", "111");
    auto value = redis.get("key");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    }

    redis.set("key", "222");
    value = redis.get("key");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    }
}

void test2(Redis& redis) {
    std::cout << "set 带有超时时间" << std::endl;
    redis.flushall();

    redis.set("key", "111", 10s);

    std::this_thread::sleep_for(3s);

    long long time = redis.ttl("key");
    std::cout << "time: " << time << std::endl;
}

void test3(Redis& redis) {
    std::cout << "set NX 和 XX" << std::endl;
    redis.flushall();

    redis.set("key", "111");

    // set 的重载版本中, 没有单独提供 NX 和 XX 的版本, 必须搭配过期时间的版本来使用. 
    redis.set("key", "222", 0s, sw::redis::UpdateType::EXIST);

    auto value = redis.get("key");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    } else {
        std::cout << "key 不存在!" << std::endl;
    }
}


int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test1(redis);
    test2(redis);
    test3(redis);
    return 0;
}

mget和mset

cpp 复制代码 
void test4(Redis& redis) {
    std::cout << "mset" << std::endl;

    redis.flushall();

    // 第一种写法, 使用初始化列表描述多个键值对
    // redis.mset({ std::make_pair("key1", "111"), std::make_pair("key2", "222"), std::make_pair("key3", "333") });

    // 第二种写法, 可以把多个键值对提前组织到容器中. 以迭代器的形式告诉 mset
    vector<std::pair<string, string>> keys = {
        {"key1", "111"},
        {"key2", "222"},
        {"key3", "333"}
    };
    redis.mset(keys.begin(), keys.end());

    auto value = redis.get("key1");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    }

    value = redis.get("key2");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    }

    value = redis.get("key3");
    if (value) {
        std::cout << "value: " << value.value() << std::endl;
    }
}

void test5(Redis& redis) {
    std::cout << "mget" << std::endl;
    redis.flushall();

    vector<std::pair<string, string>> keys = {
        {"key1", "111"},
        {"key2", "222"},
        {"key3", "333"}
    };
    redis.mset(keys.begin(), keys.end());

    vector<sw::redis::OptionalString> result;
    auto it = std::back_inserter(result);
    redis.mget({"key1", "key2", "key3", "key4"}, it);

    printContainerOptional(result);
}


int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test4(redis);
    test5(redis);
    
    return 0;
}

getrange和setrange

cpp 复制代码 
void test6(Redis& redis) {
    std::cout << "getrange 和 setrange" << std::endl;
    redis.flushall();

    redis.set("key", "abcdefghijk");

    string result = redis.getrange("key", 2, 5);
    std::cout << "result: " << result << std::endl;

    redis.setrange("key", 2, "xyz");

    auto value = redis.get("key");
    std::cout << "value: " << value.value() << std::endl;
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test6(redis);
    
    return 0;
}

incr和decr

cpp 复制代码 
void test7(Redis& redis) {
    std::cout << "incr 和 decr" << std::endl;
    redis.flushall();

    redis.set("key", "100");

    long long result = redis.incr("key");
    std::cout << "result: " << result << std::endl;

    auto value = redis.get("key");
    std::cout << "value: " << value.value() << std::endl;

    result = redis.decr("key");
    std::cout << "result: " << result << std::endl;

    value = redis.get("key");
    std::cout << "value: " << value.value() << std::endl;
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test7(redis);
    
    return 0;
}

list

lpush和lrange

cpp 复制代码 
void test1(Redis& redis) {
    std::cout << "lpush 和 lrange" << std::endl;
    redis.flushall();

    // 插入单个元素
    redis.lpush("key", "111");

    // 插入一组元素, 基于初始化列表
    redis.lpush("key", {"222", "333", "444"});

    // 插入一组元素, 基于迭代器
    vector<string> values = {"555", "666", "777"};
    redis.lpush("key", values.begin(), values.end());

    // lrange 获取到列表中的元素
    vector<string> results;
    auto it = std::back_inserter(results);
    redis.lrange("key", 0, -1, it);

    printContainer(results);
}


int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test1(redis);
    test2(redis);

    return 0;
}

rpush、lpop和rpop

cpp 复制代码 
void test2(Redis& redis) {
    std::cout << "rpush" << std::endl;
    redis.flushall();

    // 插入单个元素
    redis.rpush("key", "111");

    // 插入多个元素, 基于初始化列表
    redis.rpush("key", {"222", "333", "444"});

    // 插入多个元素, 基于容器
    vector<string> values = {"555", "666", "777"};
    redis.rpush("key", values.begin(), values.end());

    // 使用 lrange 获取元素
    vector<string> results;
    auto it = std::back_inserter(results);
    redis.lrange("key", 0, -1, it);

    printContainer(results);
}

void test3(Redis& redis) {
    std::cout << "lpop 和 rpop" << std::endl;
    redis.flushall();

    // 构造一个 list
    redis.rpush("key", {"1", "2", "3", "4"});

    auto result = redis.lpop("key");
    if (result) {
        std::cout << "lpop: " << result.value() << std::endl;
    }

    result = redis.rpop("key");
    if (result) {
        std::cout << "rpop: " << result.value() << std::endl;
    }
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test2(redis);
    test3(redis);
    return 0;
}

blpop

cpp 复制代码 
void test4(Redis& redis) {
    using namespace std::chrono_literals;
    std::cout << "blpop" << std::endl;
    redis.flushall();

    auto result = redis.blpop({"key", "key2", "key3"}, 10s);
    if (result) {
        std::cout << "key:" << result->first << std::endl;
        std::cout << "elem:" << result->second << std::endl;
    } else {
        std::cout << "result 无效!" << std::endl;
    }
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test4(redis);

    return 0;
}

llen

cpp 复制代码 
void test5(Redis& redis) {
    std::cout << "llen" << std::endl;
    redis.flushall();

    redis.lpush("key", {"111", "222", "333", "444"});
    long long len = redis.llen("key");
    std::cout << "len: " << len << std::endl;
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test5(redis);
    return 0;
}

set

sadd和smembers

cpp 复制代码 
void test1(Redis& redis) {
    std::cout << "sadd 和 smembers" << std::endl;
    redis.flushall();

    // 一次添加一个元素
    redis.sadd("key", "111");

    // 一次添加多个元素(使用初始化列表)
    redis.sadd("key", {"222", "333", "444"});

    // 一次添加多个元素(使用迭代器)
    set<string> elems = {"555", "666", "777"};
    redis.sadd("key", elems.begin(), elems.end());

    // 获取到上述元素
    // 此处用来保存 smembers 的结果, 使用 set 可能更合适. 
    vector<string> result;
    // auto it = std::back_inserter(result);
    // 由于此处 set 里的元素顺序是固定的. 指定一个 result.end() 或者 result.begin() 或者其他位置的迭代器, 都无所谓~~
    auto it = std::inserter(result, result.end());
    redis.smembers("key", it);

    printContainer(result);
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test1(redis);
    return 0;
}

sismember、spop和scard

cpp 复制代码 
void test2(Redis& redis) {
    std::cout << "sismember" << std::endl;
    redis.flushall();

    redis.sadd("key", {"111", "222", "333", "444"});

    bool result = redis.sismember("key", "555");
    std::cout << "result: " << result << std::endl;
}

void test3(Redis& redis) {
    std::cout << "scard" << std::endl;
    redis.flushall();

    redis.sadd("key", {"111", "222", "333"});
    long long result = redis.scard("key");
    std::cout << "result: " << result << std::endl;
}

void test4(Redis& redis) {
    std::cout << "spop" << std::endl;
    redis.flushall();

    redis.sadd("key", {"111", "222", "333", "444"});
    auto result = redis.spop("key");
    if (result) {
        std::cout << "result: " << result.value() << std::endl;
    } else {
        std::cout << "result 无效!" << std::endl;
    }
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test2(redis);
    test3(redis);
    test4(redis);
    return 0;
}

sinter和sinterstore

cpp 复制代码 
void test5(Redis& redis) {
    std::cout << "sinter" << std::endl;
    redis.flushall();

    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    set<string> result;
    auto it = std::inserter(result, result.end());
    redis.sinter({"key1", "key2"}, it);

    printContainer(result);
}

void test6(Redis& redis) {
    std::cout << "sinterstore" << std::endl;
    redis.flushall();

    redis.sadd("key1", {"111", "222", "333"});
    redis.sadd("key2", {"111", "222", "444"});

    long long len = redis.sinterstore("key3", {"key1", "key2"});
    std::cout << "len: " << len << std::endl;

    set<string> result;
    auto it = std::inserter(result, result.end());
    redis.smembers("key3", it);

    printContainer(result);
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test5(redis);
    test6(redis);
    return 0;
}

hash

hset和hget

cpp 复制代码 
void test1(Redis& redis) {
    std::cout << "hset 和 hget" << std::endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", std::make_pair("f2", "222"));
    // hset 能够一次性插入多个 field-value 对!!
    redis.hset("key", {
        std::make_pair("f3", "333"),
        std::make_pair("f4", "444")
    });
    vector<std::pair<string, string>> fields = {
        std::make_pair("f5", "555"),
        std::make_pair("f6", "666")
    };
    redis.hset("key", fields.begin(), fields.end());

    auto result = redis.hget("key", "f3");
    if (result) {
        std::cout << "result: " << result.value() << std::endl;
    } else {
        std::cout << "result 无效!" << std::endl;
    }
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test1(redis);

    return 0;
}

hexists、hdel和hlen

cpp 复制代码 
void test2(Redis& redis) {
    std::cout << "hexits" << std::endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    bool result = redis.hexists("key", "f4");
    std::cout << "result: " << result << std::endl;
}

void test3(Redis& redis) {
    std::cout << "hdel" << std::endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    long long result = redis.hdel("key", "f1");
    std::cout << "result: " << result << std::endl;

    result = redis.hdel("key", {"f2", "f3"});
    std::cout << "result: " << result << std::endl;

    long long len = redis.hlen("key");
    std::cout << "len: " << len << std::endl;
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test2(redis);
    test3(redis);

    return 0;
}

hkeys、hvals、hmset、hmget

cpp 复制代码 
void test4(Redis& redis) {
    std::cout << "hkeys 和 hvals" << std::endl;
    redis.flushall();

    redis.hset("key", "f1", "111");
    redis.hset("key", "f2", "222");
    redis.hset("key", "f3", "333");

    vector<string> fields;
    auto itFields = std::back_inserter(fields);
    redis.hkeys("key", itFields);
    printContainer(fields);

    vector<string> values;
    auto itValues = std::back_inserter(values);
    redis.hvals("key", itValues);
    printContainer(values);
}

void test5(Redis& redis) {
    std::cout << "hmget 和 hmset" << std::endl;
    redis.flushall();

    redis.hmset("key", {
        std::make_pair("f1", "111"),
        std::make_pair("f2", "222"),
        std::make_pair("f3", "333")
    });

    vector<std::pair<string, string>> pairs = {
        std::make_pair("f4", "444"),
        std::make_pair("f5", "555"),
        std::make_pair("f6", "666")
    };
    redis.hmset("key", pairs.begin(), pairs.end());

    vector<string> values;
    auto it = std::back_inserter(values);
    redis.hmget("key", {"f1", "f2", "f3"}, it);
    printContainer(values);
}


int main() {
    Redis redis("tcp://127.0.0.1:6379");

    test4(redis);
    test5(redis);
    return 0;
}

zset

cpp 复制代码 
void test1(Redis& redis) {
    std::cout << "zadd 和 zrange" << std::endl;
    redis.flushall();

    redis.zadd("key", "吕布", 99);
    redis.zadd("key", {
        std::make_pair("赵云", 98),
        std::make_pair("典韦", 97)
    });
    vector<std::pair<string, double>> members = {
        std::make_pair("关羽", 95),
        std::make_pair("张飞", 93)
    };
    redis.zadd("key", members.begin(), members.end());

    // zrange 支持两种主要的风格:
    // 1. 只查询 member, 不带 score
    // 2. 查询 member 同时带 score
    // 关键就是看插入迭代器指向的容器的类型. 
    // 指向的容器只是包含一个 string, 就是只查询 member
    // 指向的容器包含的是一个 pair, 里面有 string 和 double, 就是查询 member 同时带有 score
    vector<string> memberResults;
    auto it = std::back_inserter(memberResults);
    redis.zrange("key", 0, -1, it);
    printContainer(memberResults);

    vector<std::pair<string, double>> membersWithScore;
    auto it2 = std::back_inserter(membersWithScore);
    redis.zrange("key", 0, -1, it2);
    printContainerPair(membersWithScore);
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test1(redis);
    return 0;
}

zcard、zrem、zscore、zrank

cpp 复制代码 
void test2(Redis& redis) {
    std::cout << "zcard" << std::endl;
    redis.flushall();

    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    long long result = redis.zcard("key");
    std::cout << "result: " << result << std::endl;
}

void test3(Redis& redis) {
    std::cout << "zrem" << std::endl;
    redis.flushall();

    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    redis.zrem("key", "zhangsan");

    long long result = redis.zcard("key");
    std::cout << "result: " << result << std::endl;
}

void test4(Redis& redis) {
    std::cout << "zscore" << std::endl;
    redis.flushall();

    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    auto score = redis.zscore("key", "zhangsan");
    if (score) {
        std::cout << "score: " << score.value() << std::endl;
    } else {
        std::cout << "score 无效" << std::endl;
    }
}

void test5(Redis& redis) {
    std::cout << "zrank" << std::endl;
    redis.flushall();

    redis.zadd("key", "zhangsan", 90);
    redis.zadd("key", "lisi", 91);
    redis.zadd("key", "wangwu", 92);
    redis.zadd("key", "zhaoliu", 93);

    auto rank = redis.zrank("key", "zhaoliu");
    if (rank) {
        std::cout << "rank: " << rank.value() << std::endl;
    } else {
        std::cout << "rank 无效" << std::endl;
    }
}

int main() {
    Redis redis("tcp://127.0.0.1:6379");
    test2(redis);
    test3(redis);
    test4(redis);
    test5(redis);
    return 0;
}
相关推荐
剑之所向2 小时前
DataEase 做大屏，只认 2 种 SQL 格式
数据库·sql·正则表达式
我真会写代码2 小时前
Redis核心特性详解：事务、发布订阅与数据删除淘汰策略
java·数据库·redis
TDengine （老段）2 小时前
TDengine IDMP 工业数据建模 —— 数据标准化
大数据·数据库·物联网·ai·时序数据库·tdengine·涛思数据
IT 行者2 小时前
LangChain4j 集成 Redis 向量存储：我踩过的坑和选型建议
java·人工智能·redis·后端
wenlonglanying3 小时前
nginx 代理 redis
运维·redis·nginx
羊小蜜.3 小时前
Mysql 01：基础查询（SELECT）全解——从单表到多字段的完整语法
数据库·mysql·查询
猿小喵3 小时前
记录一次从库并行回放出现死锁的问题
数据库·mysql·tdsql
随风，奔跑3 小时前
Redis
数据库·redis·缓存
IvorySQL3 小时前
2MB 的 PostgreSQL work_mem，如何吃掉 2TB 内存？
数据库·postgresql·开源
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）04围棋-html版本05纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！06Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services07让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南08“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）09UV安装并设置国内源10Mac 本地部署 OMLX + 通义千问 Qwen3.5-27B 保姆级教程