Redis——redispluspls库list及set类型相关接口使用

文章目录

• • [list 类型相关接口](#list 类型相关接口)
  • • lpush和lrange
    • rpush
    • lpop和rpop
    • blpop和brpop
    • llen
  • [set 类型相关接口](#set 类型相关接口)
  • • sadd和smembers
    • sismember
    • scard
    • spop
    • sinster
    • sinterstore

list 类型相关接口

lpush和lrange

void lrange_lpush(sw::redis::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> result;
    auto it  = std::back_inserter(result);
    redis.lrange("key",0,-1,it);

    for(const auto& elem:result){
        std::cout<<elem<<std::endl;
    }
}

由于lpush是头插，所以后来的元素在前面

rpush

 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> result;
    auto it  = std::back_inserter(result);
    redis.lrange("key",0,-1,it);

    for(const auto& elem:result){
        std::cout<<elem<<std::endl;
    }

lpop和rpop

void lpop_rpop(sw::redis::Redis& redis){
    std::cout<<"rpush 和 lrange"<<std::endl;
    redis.flushall();

    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;
}

blpop和brpop

这里先了解一下blpop的返回值

什么是 OptionalStringPair, optional里面包裹了一个pair，pair里面是string

blpop要返回的内容是两个部分

1. 这个元素属于哪个list（blpop可以同时监听多个list）
2. 当前被删除的元素

blpop还可以设置超时时间，如果在指定时间内，还没有其他客户端往指定的list中插入元素，此时blpop就直接返回了，此时返回的就是一个无效值了

std::cout<<"blpop"<<std::endl;
    redis.flushall();

    auto result =  redis.blpop("key");
    if(result) {
        std::cout<<"key:"<<result.value().first<<std::endl;//result->first
        std::cout<<"elem:"<<result.value().second<<std::endl;//result->second
    }else{
        std::cout<<"result 无效"<<std::endl;
    }

这里由于没有元素在里面，blpop就被阻塞到这里了，另外开一个中端在redis-cli中插入key，就没有阻塞了

auto result = redis.blpop({"key","key2","key3"});当然也可以一次监听多个key，只要其中有一个key有元素插入，就会停止阻塞

设置超时时间

  using namespace std::chrono_literals;
    std::cout<<"blpop"<<std::endl;
    redis.flushall();

    auto result =  redis.blpop("key",5s);
    if(result) {
        std::cout<<"key:"<<result.value().first<<std::endl;
        std::cout<<"elem:"<<result.value().second<<std::endl;
    }else{
        std::cout<<"result 无效"<<std::endl;
    }

llen

void llen(sw::redis::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<<std::endl;
} 
int main()
{
    sw::redis::Redis redis("tcp://127.0.0.1:6379");
    llen(redis);
    return 0;
}

看到这里不难发现，redis-plus-plus这个库，接口设计的风格，是非常统一的

当一个函数，参数需要传递多个参数的时候，往往都是支持 初始化列表 或者是一对迭代器的方式来实现的

当一个函数 返回值需要多个数据的时候，也往往会借助插入迭代器，来实现往一个容器中添加元素的效果

当某些场景涉及到无效值的时候，往往会搭配 std::optional来进行使用

很多C++的代码，都是按照上方式来设计的

set 类型相关接口

sadd和smembers

 std::cout<<"sadd 和 smemers"<<std::endl;
    redis.flushall();

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

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

    //获取上述元素
    //vector<string> result;
    //auto it  = std::back_inserter(result);
     std::set<string> result;
    //由于set的元素的顺序是固定的，插入的位置无所谓，最终都是有序的，但是这里必须要 传入一个插入的位置
    auto it  = std::inserter(result,result.end());//begin,end,或者其他位置都可以
    redis.smembers("key",it);
    for(const auto&x:result){
        std::cout<<x<<std::endl;
    }

sismember

std::cout<<"sismember "<<std::endl;
    redis.flushall();

    redis.sadd("key",{"222","333","444"});
    bool ret =  redis.sismember("key","222");
    std::cout<<"222-ret:"<<ret<<std::endl;

    ret =  redis.sismember("key","111");
    std::cout<<"111-ret:"<<ret<<std::endl;

scard

  std::cout<<"scard "<<std::endl;
    redis.flushall();

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

spop

 std::cout<<"spop "<<std::endl;
    redis.flushall();

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

sinster

 std::cout<<"sinter "<<std::endl;
    redis.flushall();

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

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

sinterstore

 std::cout<<"sinterstore "<<std::endl;
    redis.flushall();

    redis.sadd("key1",{"222","333","444"});
    redis.sadd("key2",{"111","222","333"});
    long long len = redis.sinterstore("key3",{"key1","key2"});
    std::cout<<"len: "<<len<<std::endl;
    
    std::set<string> result;
    auto it  = std::inserter(result,result.end());
    redis.smembers("key3",it);

    for(const auto&x:result){
        std::cout<<x<<std::endl;
    }